tools/perf/tests/time-utils-test.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <linux/compiler.h>
   3 #include <linux/time64.h>
   4 #include <inttypes.h>
   5 #include <string.h>
   6 #include "time-utils.h"
   7 #include "evlist.h"
   8 #include "session.h"
   9 #include "debug.h"
  10 #include "tests.h"
  11
  12 static bool test__parse_nsec_time(const char *str, u64 expected)
  13 {
  14         u64 ptime;
  15         int err;
  16
  17         pr_debug("\nparse_nsec_time(\"%s\")\n", str);
  18
  19         err = parse_nsec_time(str, &ptime);
  20         if (err) {
  21                 pr_debug("error %d\n", err);
  22                 return false;
  23         }
  24
  25         if (ptime != expected) {
  26                 pr_debug("Failed. ptime %" PRIu64 " expected %" PRIu64 "\n",
  27                          ptime, expected);
  28                 return false;
  29         }
  30
  31         pr_debug("%" PRIu64 "\n", ptime);
  32
  33         return true;
  34 }
  35
  36 static bool test__perf_time__parse_str(const char *ostr, u64 start, u64 end)
  37 {
  38         struct perf_time_interval ptime;
  39         int err;
  40
  41         pr_debug("\nperf_time__parse_str(\"%s\")\n", ostr);
  42
  43         err = perf_time__parse_str(&ptime, ostr);
  44         if (err) {
  45                 pr_debug("Error %d\n", err);
  46                 return false;
  47         }
  48
  49         if (ptime.start != start || ptime.end != end) {
  50                 pr_debug("Failed. Expected %" PRIu64 " to %" PRIu64 "\n",
  51                          start, end);
  52                 return false;
  53         }
  54
  55         return true;
  56 }
  57
  58 #define TEST_MAX 64
  59
  60 struct test_data {
  61         const char *str;
  62         u64 first;
  63         u64 last;
  64         struct perf_time_interval ptime[TEST_MAX];
  65         int num;
  66         u64 skip[TEST_MAX];
  67         u64 noskip[TEST_MAX];
  68 };
  69
  70 static bool test__perf_time__parse_for_ranges(struct test_data *d)
  71 {
  72         struct evlist evlist = {
  73                 .first_sample_time = d->first,
  74                 .last_sample_time = d->last,
  75         };
  76         struct perf_session session = { .evlist = &evlist };
  77         struct perf_time_interval *ptime = NULL;
  78         int range_size, range_num;
  79         bool pass = false;
  80         int i, err;
  81
  82         pr_debug("\nperf_time__parse_for_ranges(\"%s\")\n", d->str);
  83
  84         if (strchr(d->str, '%'))
  85                 pr_debug("first_sample_time %" PRIu64 " last_sample_time %" PRIu64 "\n",
  86                          d->first, d->last);
  87
  88         err = perf_time__parse_for_ranges(d->str, &session, &ptime, &range_size,
  89                                           &range_num);
  90         if (err) {
  91                 pr_debug("error %d\n", err);
  92                 goto out;
  93         }
  94
  95         if (range_size < d->num || range_num != d->num) {
  96                 pr_debug("bad size: range_size %d range_num %d expected num %d\n",
  97                          range_size, range_num, d->num);
  98                 goto out;
  99         }
 100
 101         for (i = 0; i < d->num; i++) {
 102                 if (ptime[i].start != d->ptime[i].start ||
 103                     ptime[i].end != d->ptime[i].end) {
 104                         pr_debug("bad range %d expected %" PRIu64 " to %" PRIu64 "\n",
 105                                  i, d->ptime[i].start, d->ptime[i].end);
 106                         goto out;
 107                 }
 108         }
 109
 110         if (perf_time__ranges_skip_sample(ptime, d->num, 0)) {
 111                 pr_debug("failed to keep 0\n");
 112                 goto out;
 113         }
 114
 115         for (i = 0; i < TEST_MAX; i++) {
 116                 if (d->skip[i] &&
 117                     !perf_time__ranges_skip_sample(ptime, d->num, d->skip[i])) {
 118                         pr_debug("failed to skip %" PRIu64 "\n", d->skip[i]);
 119                         goto out;
 120                 }
 121                 if (d->noskip[i] &&
 122                     perf_time__ranges_skip_sample(ptime, d->num, d->noskip[i])) {
 123                         pr_debug("failed to keep %" PRIu64 "\n", d->noskip[i]);
 124                         goto out;
 125                 }
 126         }
 127
 128         pass = true;
 129 out:
 130         free(ptime);
 131         return pass;
 132 }
 133
 134 int test__time_utils(struct test *t __maybe_unused, int subtest __maybe_unused)
 135 {
 136         bool pass = true;
 137
 138         pass &= test__parse_nsec_time("0", 0);
 139         pass &= test__parse_nsec_time("1", 1000000000ULL);
 140         pass &= test__parse_nsec_time("0.000000001", 1);
 141         pass &= test__parse_nsec_time("1.000000001", 1000000001ULL);
 142         pass &= test__parse_nsec_time("123456.123456", 123456123456000ULL);
 143         pass &= test__parse_nsec_time("1234567.123456789", 1234567123456789ULL);
 144         pass &= test__parse_nsec_time("18446744073.709551615",
 145                                       0xFFFFFFFFFFFFFFFFULL);
 146
 147         pass &= test__perf_time__parse_str("1234567.123456789,1234567.123456789",
 148                                            1234567123456789ULL, 1234567123456789ULL);
 149         pass &= test__perf_time__parse_str("1234567.123456789,1234567.123456790",
 150                                            1234567123456789ULL, 1234567123456790ULL);
 151         pass &= test__perf_time__parse_str("1234567.123456789,",
 152                                            1234567123456789ULL, 0);
 153         pass &= test__perf_time__parse_str(",1234567.123456789",
 154                                            0, 1234567123456789ULL);
 155         pass &= test__perf_time__parse_str("0,1234567.123456789",
 156                                            0, 1234567123456789ULL);
 157
 158         {
 159                 u64 b = 1234567123456789ULL;
 160                 struct test_data d = {
 161                         .str   = "1234567.123456789,1234567.123456790",
 162                         .ptime = { {b, b + 1}, },
 163                         .num = 1,
 164                         .skip = { b - 1, b + 2, },
 165                         .noskip = { b, b + 1, },
 166                 };
 167
 168                 pass &= test__perf_time__parse_for_ranges(&d);
 169         }
 170
 171         {
 172                 u64 b = 1234567123456789ULL;
 173                 u64 c = 7654321987654321ULL;
 174                 u64 e = 8000000000000000ULL;
 175                 struct test_data d = {
 176                         .str   = "1234567.123456789,1234567.123456790 "
 177                                  "7654321.987654321,7654321.987654444 "
 178                                  "8000000,8000000.000000005",
 179                         .ptime = { {b, b + 1}, {c, c + 123}, {e, e + 5}, },
 180                         .num = 3,
 181                         .skip = { b - 1, b + 2, c - 1, c + 124, e - 1, e + 6 },
 182                         .noskip = { b, b + 1, c, c + 123, e, e + 5 },
 183                 };
 184
 185                 pass &= test__perf_time__parse_for_ranges(&d);
 186         }
 187
 188         {
 189                 u64 b = 7654321ULL * NSEC_PER_SEC;
 190                 struct test_data d = {
 191                         .str    = "10%/1",
 192                         .first  = b,
 193                         .last   = b + 100,
 194                         .ptime  = { {b, b + 9}, },
 195                         .num    = 1,
 196                         .skip   = { b - 1, b + 10, },
 197                         .noskip = { b, b + 9, },
 198                 };
 199
 200                 pass &= test__perf_time__parse_for_ranges(&d);
 201         }
 202
 203         {
 204                 u64 b = 7654321ULL * NSEC_PER_SEC;
 205                 struct test_data d = {
 206                         .str    = "10%/2",
 207                         .first  = b,
 208                         .last   = b + 100,
 209                         .ptime  = { {b + 10, b + 19}, },
 210                         .num    = 1,
 211                         .skip   = { b + 9, b + 20, },
 212                         .noskip = { b + 10, b + 19, },
 213                 };
 214
 215                 pass &= test__perf_time__parse_for_ranges(&d);
 216         }
 217
 218         {
 219                 u64 b = 11223344ULL * NSEC_PER_SEC;
 220                 struct test_data d = {
 221                         .str    = "10%/1,10%/2",
 222                         .first  = b,
 223                         .last   = b + 100,
 224                         .ptime  = { {b, b + 9}, {b + 10, b + 19}, },
 225                         .num    = 2,
 226                         .skip   = { b - 1, b + 20, },
 227                         .noskip = { b, b + 8, b + 9, b + 10, b + 11, b + 12, b + 19, },
 228                 };
 229
 230                 pass &= test__perf_time__parse_for_ranges(&d);
 231         }
 232
 233         {
 234                 u64 b = 11223344ULL * NSEC_PER_SEC;
 235                 struct test_data d = {
 236                         .str    = "10%/1,10%/3,10%/10",
 237                         .first  = b,
 238                         .last   = b + 100,
 239                         .ptime  = { {b, b + 9}, {b + 20, b + 29}, { b + 90, b + 100}, },
 240                         .num    = 3,
 241                         .skip   = { b - 1, b + 10, b + 19, b + 30, b + 89, b + 101 },
 242                         .noskip = { b, b + 9, b + 20, b + 29, b + 90, b + 100},
 243                 };
 244
 245                 pass &= test__perf_time__parse_for_ranges(&d);
 246         }
 247
 248         pr_debug("\n");
 249
 250         return pass ? 0 : TEST_FAIL;
 251 }