Improve t-test handling by multiple contexts

Previously, a single 't_context_t' instance was used for all statistical
tests, limiting the ability to assess multiple cropping thresholds
independently.

This change allows separate t-tests for different percentiles of
execution times, ensuring more robust statistical analysis.

To achieve this, the following changes were made:
- Replaced the single 't_context_t' instance with an array 'ctxs[]' to
  track multiple contexts.
- Introduced 'DUDECT_TESTS' to define the total number of tests,
  including the baseline.
- Updated 'update_statistics()' to push values into the appropriate
  context based on percentile filtering.
- Implemented 'max_test()' to determine the test context with the
  maximum t-value.
- Adjusted memory allocation and cleanup for multiple contexts.

This enhances the ability to detect timing differences at various
thresholds, improving test reliability.

Change-Id: Icfad85854765316dece6d1303c5e13ad1e8ab8e9

Author: BennyWang1007

dudect/fixture.c

@@ -42,9 +42,12 @@
 
 #define ENOUGH_MEASURE 10000
 #define TEST_TRIES 10
+
+/* Number of percentiles to calculate */
 #define NUM_PERCENTILES (100)
+#define DUDECT_TESTS (NUM_PERCENTILES + 1)
 
-static t_context_t *t;
+static t_context_t *ctxs[DUDECT_TESTS];
 
 /* threshold values for Welch's t-test */
 enum {
@@ -70,10 +73,10 @@ static int cmp(const int64_t *a, const int64_t *b)
 }
 
 /* This function is used to set different thresholds for cropping measurements.
- * To filter out the slowest measurements, we keep only the fastest ones by a
- * complementary exponential decay scale as threshold for cropping measurements:
- * threshold(x) = 1 - 0.5^(10 * x / N_MEASURES), where x is the counter of the measurement.
- * This way we will have more tolerance for the first measurements and less for the last ones.
+ * To filter out slow measurements, we keep only the fastest ones by a
+ * complementary exponential decay scale as thresholds for cropping
+ * measurements: threshold(x) = 1 - 0.5^(10 * x / N_MEASURES), where x is the
+ * counter of the measurement.
  */
 static void prepare_percentiles(int64_t *exec_times, int64_t *percentiles)
 {
@@ -106,19 +109,35 @@ static void update_statistics(const int64_t *exec_times,
             continue;
 
         /* do a t-test on the execution time */
-        t_push(t, difference, classes[i]);
+        t_push(ctxs[0], difference, classes[i]);
 
-        /* t-test on cropped execution times, for several cropping thresholds. */
+        /* t-test on cropped execution times, for several cropping thresholds.
+         */
         for (size_t j = 0; j < NUM_PERCENTILES; j++) {
             if (difference < percentiles[j]) {
-                t_push(t, difference, classes[i]);
+                t_push(ctxs[j + 1], difference, classes[i]);
             }
         }
     }
 }
 
+static t_context_t *max_test()
+{
+    size_t max_idx = 0;
+    double max_t = 0.0f;
+    for (size_t i = 0; i < NUM_PERCENTILES + 1; i++) {
+        double t = fabs(t_compute(ctxs[i]));
+        if (t > max_t) {
+            max_t = t;
+            max_idx = i;
+        }
+    }
+    return ctxs[max_idx];
+}
+
 static bool report(void)
 {
+    t_context_t *t = max_test();
     double max_t = fabs(t_compute(t));
     double number_traces_max_t = t->n[0] + t->n[1];
     double max_tau = max_t / sqrt(number_traces_max_t);
@@ -191,13 +210,15 @@ static bool doit(int mode)
 static void init_once(void)
 {
     init_dut();
-    t_init(t);
+    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;
-    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);
@@ -209,7 +230,11 @@ static bool test_const(char *text, int mode)
         if (result)
             break;
     }
-    free(t);
+
+    for (size_t i = 0; i < DUDECT_TESTS; i++) {
+        free(ctxs[i]);
+    }
+
     return result;
 }