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

This commit resolves memory leaks in the original implementation and
improves stability with a warm-up phase. Previously, the initialization
function was called multiple times within the testing function,
reallocating memory for the context array without releasing earlier
allocations, resulting in leaks detected by Valgrind (43,632 bytes
across 909 blocks per test). Now, the initialization happens only once,
and memory is released when testing completes, preventing any leaks.

Additionally, a warm-up step is added in the measurement function by
discarding the first batch of data. This filters out initial anomalies
(such as cache misses or memory allocation delays), aligning with the
design principles of the dudect framework and enhancing measurement
consistency. Previous Chinese comments are also translated to English
for better readability.

These changes ensure reliability, eliminate memory issues, and adhere
to the lightweight and stable testing approach outlined in the
dudect paper.

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;