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

The original plan was to explore adding a warm-up step to the
measurement function, motivated by a privately implemented earlier
version that included this feature and successfully passed tests for
queue-related functions, unlike the current stricter version which
lacked it and failed those tests. Before implementing this change,
Valgrind inspection was performed on the original code without the
warm-up step, revealing memory leaks with 43,632 bytes lost across
909 blocks per test. Analysis showed that the initialization function
was being called repeatedly within the testing loop, each time
reallocating the context array without any provision to free prior
memory allocations. This uncontrolled repetition caused memory to
accumulate not freed over multiple test iterations, leading to the
observed leaks. To address this issue in the original code, the
initialization process was revised to execute only once before testing
begins, and a cleanup was added to release all allocated memory
when testing concludes, fully resolving the memory leak problem.

After resolving the memory leaks, the warm-up step was added to
discard the first batch of data, and tests were conducted to determine
its impact on the constant-time behavior of queue insertion and removal
functions. To isolate its effect, the original flawed memory release
approach was temporarily restored, revealing persistent memory-related
issues that prevented reliable test outcomes. Once the corrected memory
release method was applied alongside the warm-up step, all
memory-related problems disappeared, and the tests passed successfully.
The decision to retain the warm-up code is based primarily on the
dudect paper, which points out that factors like cache misses or memory
allocation delays could, under different conditions, affect t-test
results. The expectation is that in certain future test scenarios, the
warm-up step may enhance t-test precision, justifying its inclusion in
this submission.

Change-Id: I06a74a7ecf1ca08f79ded70d91e4b33ed7cf141b

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;