* Re: [PATCH v9] Fix time/tst-cpuclock1 intermitent failures
2020-04-21 17:44 ` [PATCH v9] " Lucas A. M. Magalhaes via Libc-alpha
@ 2020-05-11 17:41 ` Lucas A. M. Magalhaes via Libc-alpha
2020-05-25 11:46 ` Lucas A. M. Magalhaes via Libc-alpha
2020-06-08 16:52 ` Carlos O'Donell via Libc-alpha
2020-06-12 15:28 ` [PATCH v10] " Lucas A. M. Magalhaes via Libc-alpha
2 siblings, 1 reply; 44+ messages in thread
From: Lucas A. M. Magalhaes via Libc-alpha @ 2020-05-11 17:41 UTC (permalink / raw)
To: libc-alpha
PING.
Quoting Lucas A. M. Magalhaes via Libc-alpha (2020-04-21 14:44:56)
> This test fails intermittently in systems with heavy load as
> CLOCK_PROCESS_CPUTIME_ID is subject to scheduler pressure. Thus the
> test boundaries were relaxed to keep it from failing on such systems.
>
> A refactor of the spent time checking was made with some support
> functions. With the advantage to representing time jitter in percent
> of the target.
>
> The values used by the test boundaries are all empirical.
>
> ---
>
> Hi Carlos,
> I also got skeptical about my dataset so I genegerated another one.
> That .4 boundry was indeed too low. Also, the support/tst-timespec was
> not actually running any tests because of a lazy bug, sorry about that.
> Thanks for taking the time for reviewing this.
>
> changes on V9:
> Add new testcases
> Fix support/tst-timespec do_run
> Add comments
> Change boundaries
>
> changes on V8:
> Add support_timespec_ns
> Add more tests
>
> This list of changes where getting to long.
> ---
> support/Makefile | 1 +
> support/timespec.c | 64 +++++++++
> support/timespec.h | 8 ++
> support/tst-timespec.c | 320 +++++++++++++++++++++++++++++++++++++++++
> time/tst-cpuclock1.c | 52 +++----
> 5 files changed, 415 insertions(+), 30 deletions(-)
> create mode 100644 support/tst-timespec.c
>
> diff --git a/support/Makefile b/support/Makefile
> index 6e38b87ebe..cacaac96a5 100644
> --- a/support/Makefile
> +++ b/support/Makefile
> @@ -233,6 +233,7 @@ tests = \
> tst-test_compare \
> tst-test_compare_blob \
> tst-test_compare_string \
> + tst-timespec \
> tst-xreadlink \
> tst-xsigstack \
>
> diff --git a/support/timespec.c b/support/timespec.c
> index ea6b947546..103beafdc4 100644
> --- a/support/timespec.c
> +++ b/support/timespec.c
> @@ -19,6 +19,8 @@
> #include <support/timespec.h>
> #include <stdio.h>
> #include <stdint.h>
> +#include <assert.h>
> +#include <intprops.h>
>
> void
> test_timespec_before_impl (const char *file, int line,
> @@ -57,3 +59,65 @@ test_timespec_equal_or_after_impl (const char *file, int line,
> (intmax_t) diff.tv_sec, (intmax_t) diff.tv_nsec);
> }
> }
> +
> +/* Convert TIME to nanoseconds stored in shrinked in a long.
> + Returns long maximum or minimum if the conversion overflows
> + or underflows, respectively. */
> +long
> +support_timespec_ns (struct timespec time)
> +{
> + long time_ns;
> + if (INT_MULTIPLY_WRAPV(time.tv_sec, TIMESPEC_HZ, &time_ns))
> + {
> + return (time.tv_sec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long);
> + }
> + if (INT_ADD_WRAPV(time_ns, time.tv_nsec, &time_ns))
> + {
> + return (time.tv_nsec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long);
> + }
> + return time_ns;
> +}
> +
> +/* Returns t normalized timespec with .tv_nsec < TIMESPEC_HZ
> + and the whole seconds added to .tv_sec. If an overflow or
> + underflow occurs the values are clamped to its maximum or
> + minimum respectively. */
> +struct timespec
> +support_timespec_normalize (struct timespec time)
> +{
> + struct timespec norm;
> + if (INT_ADD_WRAPV (time.tv_sec, (time.tv_nsec / TIMESPEC_HZ), &norm.tv_sec))
> + {
> + norm.tv_sec = (time.tv_nsec < 0) ? TYPE_MINIMUM (time_t): TYPE_MAXIMUM (time_t);
> + norm.tv_nsec = (time.tv_nsec < 0) ? -1 * (TIMESPEC_HZ - 1) : TIMESPEC_HZ - 1;
> + return norm;
> + }
> + norm.tv_nsec = time.tv_nsec % TIMESPEC_HZ;
> + return norm;
> +}
> +
> +/* Returns TRUE if the observed time is within the given percentage
> + bounds of the expected time, and FALSE otherwise.
> + For example the call
> +
> + support_timespec_check_in_range(expected, observed, .5, 1.2);
> +
> + will check if
> +
> + .5 <= observed/expected <= 1.2
> +
> + In other words it will check if observed time is within 50% to
> + 120% of the expected time. */
> +int
> +support_timespec_check_in_range (struct timespec expected, struct timespec observed,
> + double lower_bound, double upper_bound)
> +{
> + assert (upper_bound >= lower_bound);
> + long expected_norm, observed_norm;
> + expected_norm = support_timespec_ns (expected);
> + /* Don't divide by zero */
> + assert(expected_norm != 0);
> + observed_norm = support_timespec_ns (observed);
> + double ratio = (double)observed_norm / expected_norm;
> + return (lower_bound <= ratio && ratio <= upper_bound);
> +}
> diff --git a/support/timespec.h b/support/timespec.h
> index c5852dfe75..fd5466745d 100644
> --- a/support/timespec.h
> +++ b/support/timespec.h
> @@ -48,6 +48,14 @@ void test_timespec_equal_or_after_impl (const char *file, int line,
> const struct timespec left,
> const struct timespec right);
>
> +long support_timespec_ns (struct timespec time);
> +
> +struct timespec support_timespec_normalize (struct timespec time);
> +
> +int support_timespec_check_in_range (struct timespec expected, struct timespec observed,
> + double lower_bound, double upper_bound);
> +
> +
> /* Check that the timespec on the left represents a time before the
> time on the right. */
> #define TEST_TIMESPEC_BEFORE(left, right) \
> diff --git a/support/tst-timespec.c b/support/tst-timespec.c
> new file mode 100644
> index 0000000000..b421b219fd
> --- /dev/null
> +++ b/support/tst-timespec.c
> @@ -0,0 +1,320 @@
> +/* Test for support_timespec_check_in_range function.
> + Copyright (C) 2020 Free Software Foundation, Inc.
> + This file is part of the GNU C Library.
> +
> + The GNU C Library is free software; you can redistribute it and/or
> + modify it under the terms of the GNU Lesser General Public
> + License as published by the Free Software Foundation; either
> + version 2.1 of the License, or (at your option) any later version.
> +
> + The GNU C Library is distributed in the hope that it will be useful,
> + but WITHOUT ANY WARRANTY; without even the implied warranty of
> + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> + Lesser General Public License for more details.
> +
> + You should have received a copy of the GNU Lesser General Public
> + License along with the GNU C Library; if not, see
> + <https://www.gnu.org/licenses/>. */
> +
> +#include <support/timespec.h>
> +#include <support/check.h>
> +#include <limits.h>
> +
> +#define TIMESPEC_HZ 1000000000
> +
> +struct timespec_ns_test_case
> +{
> + struct timespec time;
> + long time_ns;
> +};
> +
> +struct timespec_norm_test_case
> +{
> + struct timespec time;
> + struct timespec norm;
> +};
> +
> +struct timespec_test_case
> +{
> + struct timespec expected;
> + struct timespec observed;
> + double upper_bound;
> + double lower_bound;
> + int result;
> +};
> +
> +/* Test cases for timespec_ns */
> +struct timespec_ns_test_case ns_cases[] = {
> + {.time = {.tv_sec = 0, .tv_nsec = 0},
> + .time_ns = 0,
> + },
> + {.time = {.tv_sec = 0, .tv_nsec = 1},
> + .time_ns = 1,
> + },
> + {.time = {.tv_sec = 1, .tv_nsec = 0},
> + .time_ns = TIMESPEC_HZ,
> + },
> + {.time = {.tv_sec = 1, .tv_nsec = 1},
> + .time_ns = TIMESPEC_HZ + 1,
> + },
> + {.time = {.tv_sec = 0, .tv_nsec = -1},
> + .time_ns = -1,
> + },
> + {.time = {.tv_sec = -1, .tv_nsec = 0},
> + .time_ns = -TIMESPEC_HZ,
> + },
> + {.time = {.tv_sec = -1, .tv_nsec = -1},
> + .time_ns = -TIMESPEC_HZ - 1,
> + },
> + {.time = {.tv_sec = 1, .tv_nsec = -1},
> + .time_ns = TIMESPEC_HZ - 1,
> + },
> + {.time = {.tv_sec = -1, .tv_nsec = 1},
> + .time_ns = -TIMESPEC_HZ + 1,
> + },
> + // Overflow bondary by 2
> + {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ, .tv_nsec = LONG_MAX%TIMESPEC_HZ - 1},
> + .time_ns = LONG_MAX - 1,
> + },
> + // Overflow bondary
> + {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ, .tv_nsec = LONG_MAX%TIMESPEC_HZ},
> + .time_ns = LONG_MAX,
> + },
> + // Underflow bondary by 1
> + {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ, .tv_nsec = LONG_MIN%TIMESPEC_HZ + 1},
> + .time_ns = LONG_MIN + 1,
> + },
> + // Underflow bondary
> + {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ, .tv_nsec = LONG_MIN%TIMESPEC_HZ},
> + .time_ns = LONG_MIN,
> + },
> + // Multiplication overflow
> + {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ + 1, .tv_nsec = 1},
> + .time_ns = LONG_MAX,
> + },
> + // Multiplication underflow
> + {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ - 1, .tv_nsec = -1},
> + .time_ns = LONG_MIN,
> + },
> + // Sum overflows
> + {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ, .tv_nsec = LONG_MAX%TIMESPEC_HZ + 1},
> + .time_ns = LONG_MAX,
> + },
> + // Sum underflow
> + {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ, .tv_nsec = LONG_MIN%TIMESPEC_HZ - 1},
> + .time_ns = LONG_MIN,
> + }
> +};
> +
> +/* Test cases for timespec_norm */
> +struct timespec_norm_test_case norm_cases[] = {
> + // Positive cases
> + {.time = {.tv_sec = 0, .tv_nsec = 0},
> + .norm = {.tv_sec = 0, .tv_nsec = 0}
> + },
> + {.time = {.tv_sec = 1, .tv_nsec = 0},
> + .norm = {.tv_sec = 1, .tv_nsec = 0}
> + },
> + {.time = {.tv_sec = 0, .tv_nsec = 1},
> + .norm = {.tv_sec = 0, .tv_nsec = 1}
> + },
> + {.time = {.tv_sec = 0, .tv_nsec = TIMESPEC_HZ},
> + .norm = {.tv_sec = 1, .tv_nsec = 0}
> + },
> + {.time = {.tv_sec = 0, .tv_nsec = TIMESPEC_HZ + 1},
> + .norm = {.tv_sec = 1, .tv_nsec = 1}
> + },
> + {.time = {.tv_sec = 1, .tv_nsec = TIMESPEC_HZ},
> + .norm = {.tv_sec = 2, .tv_nsec = 0}
> + },
> + {.time = {.tv_sec = 1, .tv_nsec = TIMESPEC_HZ + 1},
> + .norm = {.tv_sec = 2, .tv_nsec = 1}
> + },
> + // Negative cases
> + {.time = {.tv_sec = 0, .tv_nsec = -TIMESPEC_HZ},
> + .norm = {.tv_sec = -1, .tv_nsec = 0}
> + },
> + {.time = {.tv_sec = 0, .tv_nsec = -TIMESPEC_HZ - 1},
> + .norm = {.tv_sec = -1, .tv_nsec = -1}
> + },
> + {.time = {.tv_sec = -1, .tv_nsec = -TIMESPEC_HZ},
> + .norm = {.tv_sec = -2, .tv_nsec = 0}
> + },
> + {.time = {.tv_sec = -1, .tv_nsec = -TIMESPEC_HZ - 1},
> + .norm = {.tv_sec = -2, .tv_nsec = -1}
> + },
> + // Overflow bondary by 2
> + {.time = {.tv_sec = LONG_MAX - 2, .tv_nsec = TIMESPEC_HZ + 1},
> + .norm = {.tv_sec = LONG_MAX - 1, 1},
> + },
> + // Overflow bondary by 1
> + {.time = {.tv_sec = LONG_MAX - 1, .tv_nsec = TIMESPEC_HZ + 1},
> + .norm = {.tv_sec = LONG_MAX, .tv_nsec = 1},
> + },
> + // Underflow bondary by 2
> + {.time = {.tv_sec = LONG_MIN + 2, .tv_nsec = -TIMESPEC_HZ - 1},
> + .norm = {.tv_sec = LONG_MIN + 1, -1},
> + },
> + // Underflow bondary by 1
> + {.time = {.tv_sec = LONG_MIN + 1, .tv_nsec = -TIMESPEC_HZ - 1},
> + .norm = {.tv_sec = LONG_MIN, .tv_nsec = -1},
> + },
> + // SUM overflow
> + {.time = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> + .norm = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ - 1},
> + },
> + // SUM underflow
> + {.time = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> + .norm = {.tv_sec = LONG_MIN, .tv_nsec = -1 * (TIMESPEC_HZ - 1)},
> + }
> +};
> +
> +/* Test cases for timespec_check_in_range */
> +struct timespec_test_case check_cases[] = {
> + // 0 - In range
> + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> + .observed = {.tv_sec = 1, .tv_nsec = 0},
> + .upper_bound = 1, .lower_bound = 1, .result = 1,
> + },
> + // 1 - Out of range
> + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> + .observed = {.tv_sec = 2, .tv_nsec = 0},
> + .upper_bound = 1, .lower_bound = 1, .result = 0,
> + },
> + // 2 - Upper Bound
> + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> + .observed = {.tv_sec = 2, .tv_nsec = 0},
> + .upper_bound = 2, .lower_bound = 1, .result = 1,
> + },
> + // 3 - Lower Bound
> + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> + .observed = {.tv_sec = 0, .tv_nsec = 0},
> + .upper_bound = 1, .lower_bound = 0, .result = 1,
> + },
> + // 4 - Out of range by nanosecs
> + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> + .observed = {.tv_sec = 1, .tv_nsec = 500},
> + .upper_bound = 1, .lower_bound = 1, .result = 0,
> + },
> + // 5 - In range by nanosecs
> + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> + .observed = {.tv_sec = 1, .tv_nsec = 50000},
> + .upper_bound = 1.3, .lower_bound = 1, .result = 1,
> + },
> + // 6 - Big nanosecs
> + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> + .observed = {.tv_sec = 0, .tv_nsec = 4000000},
> + .upper_bound = 1, .lower_bound = .001, .result = 1,
> + },
> + // 7 - In range Negative values
> + {.expected = {.tv_sec = -1, .tv_nsec = 0},
> + .observed = {.tv_sec = -1, .tv_nsec = 0},
> + .upper_bound = 1, .lower_bound = 1, .result = 1,
> + },
> + // 8 - Out of range Negative values
> + {.expected = {.tv_sec = -1, .tv_nsec = 0},
> + .observed = {.tv_sec = -1, .tv_nsec = 0},
> + .upper_bound = -1, .lower_bound = -1, .result = 0,
> + },
> + // 9 - Negative values with negative nanosecs
> + {.expected = {.tv_sec = -1, .tv_nsec = 0},
> + .observed = {.tv_sec = -1, .tv_nsec = -2000},
> + .upper_bound = 1, .lower_bound = 1, .result = 0,
> + },
> + // 10 - Strict bounds
> + {.expected = {.tv_sec = -1, .tv_nsec = 0},
> + .observed = {.tv_sec = -1, .tv_nsec = -20000},
> + .upper_bound = 1.00002, .lower_bound = 1.0000191, .result = 1,
> + },
> + // 11 - Strict bounds with loose upper bound
> + {.expected = {.tv_sec = 1, .tv_nsec = 20000},
> + .observed = {.tv_sec = 1, .tv_nsec = 30000},
> + .upper_bound = 1.0000100000, .lower_bound = 1.0000099998, .result = 1,
> + },
> + // 12 - Strict bounds with loose lower bound
> + {.expected = {.tv_sec = 1, .tv_nsec = 20000},
> + .observed = {.tv_sec = 1, .tv_nsec = 30000},
> + .upper_bound = 1.0000099999, .lower_bound = 1.00000999979, .result = 1,
> + },
> + // 13 - Strict bounds highest precision
> + {.expected = {.tv_sec = 1, .tv_nsec = 20000},
> + .observed = {.tv_sec = 1, .tv_nsec = 30000},
> + .upper_bound = 1.00000999980001, .lower_bound = 1.00000999979999, .result = 1,
> + },
> + /* Maximum/Minimum long values */
> + // 14
> + {.expected = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ - 1},
> + .observed = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ - 2},
> + .upper_bound = 1, .lower_bound = .9, .result = 1,
> + },
> + // 15 - support_timespec_ns overflow
> + {.expected = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> + .observed = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> + .upper_bound = 1, .lower_bound = 1, .result = 1,
> + },
> + // 16 - support_timespec_ns overflow + underflow
> + {.expected = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> + .observed = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> + .upper_bound = 1, .lower_bound = 1, .result = 0,
> + },
> + // 17 - support_timespec_ns underflow
> + {.expected = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> + .observed = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> + .upper_bound = 1, .lower_bound = 1, .result = 1,
> + },
> + // 18 - support_timespec_ns underflow + overflow
> + {.expected = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> + .observed = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> + .upper_bound = 1, .lower_bound = 1, .result = 0,
> + },
> + // 19 - Biggest division
> + {.expected = {.tv_sec = LONG_MAX / TIMESPEC_HZ , .tv_nsec = TIMESPEC_HZ - 1},
> + .observed = {.tv_sec = 0, .tv_nsec = 1},
> + .upper_bound = 1, .lower_bound = 1.0842021724855044e-19, .result = 1,
> + },
> + // 20 - Lowest division
> + {.expected = {.tv_sec = 0, .tv_nsec = 1},
> + .observed = {.tv_sec = LONG_MAX / TIMESPEC_HZ , .tv_nsec = TIMESPEC_HZ - 1},
> + .upper_bound = LONG_MAX, .lower_bound = 1, .result = 1,
> + },
> +};
> +
> +static int
> +do_test (void)
> +{
> + int i = 0;
> + int ntests = sizeof (ns_cases) / sizeof (ns_cases[0]);
> +
> + printf("Testing support_timespec_ns\n");
> + for (i = 0; i < ntests; i++)
> + {
> + TEST_COMPARE (support_timespec_ns (ns_cases[i].time),
> + ns_cases[i].time_ns);
> + }
> +
> + ntests = sizeof (norm_cases) / sizeof (norm_cases[0]);
> + struct timespec result;
> + printf("Testing support_timespec_normalize\n");
> + for (i = 0; i < ntests; i++)
> + {
> + result = support_timespec_normalize (norm_cases[i].time);
> + TEST_COMPARE (norm_cases[i].norm.tv_sec, result.tv_sec);
> + TEST_COMPARE (norm_cases[i].norm.tv_nsec, result.tv_nsec);
> + }
> +
> + ntests = sizeof (check_cases) / sizeof (check_cases[0]);
> + printf("Testing support_timespec_check_in_range\n");
> + for (i = 0; i < ntests; i++)
> + {
> + /* Its hard to find which test failed with just the TEST_COMPARE report.
> + So here we print every running testcase as well. */
> + printf("Test case %d\n", i);
> + TEST_COMPARE (support_timespec_check_in_range
> + (check_cases[i].expected, check_cases[i].observed,
> + check_cases[i].lower_bound,
> + check_cases[i].upper_bound), check_cases[i].result);
> + }
> + return 0;
> +}
> +
> +#include <support/test-driver.c>
> diff --git a/time/tst-cpuclock1.c b/time/tst-cpuclock1.c
> index 0120906f23..1ac611a92b 100644
> --- a/time/tst-cpuclock1.c
> +++ b/time/tst-cpuclock1.c
> @@ -26,6 +26,7 @@
> #include <signal.h>
> #include <stdint.h>
> #include <sys/wait.h>
> +#include <support/timespec.h>
>
> /* This function is intended to rack up both user and system time. */
> static void
> @@ -155,16 +156,12 @@ do_test (void)
> printf ("live PID %d after sleep => %ju.%.9ju\n",
> child, (uintmax_t) after.tv_sec, (uintmax_t) after.tv_nsec);
>
> - struct timespec diff = { .tv_sec = after.tv_sec - before.tv_sec,
> - .tv_nsec = after.tv_nsec - before.tv_nsec };
> - if (diff.tv_nsec < 0)
> - {
> - --diff.tv_sec;
> - diff.tv_nsec += 1000000000;
> - }
> - if (diff.tv_sec != 0
> - || diff.tv_nsec > 600000000
> - || diff.tv_nsec < 100000000)
> + /* The bound values are empirically defined by testing this code over high cpu
> + usage and different nice values. Of all the values we keep the 90th
> + percentile of values and use those values for our testing allowed range. */
> + struct timespec diff = timespec_sub (support_timespec_normalize (after),
> + support_timespec_normalize (before));
> + if (!support_timespec_check_in_range (sleeptime, diff, .9, 1.1))
> {
> printf ("before - after %ju.%.9ju outside reasonable range\n",
> (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> @@ -194,19 +191,16 @@ do_test (void)
> }
> else
> {
> - struct timespec d = { .tv_sec = afterns.tv_sec - after.tv_sec,
> - .tv_nsec = afterns.tv_nsec - after.tv_nsec };
> - if (d.tv_nsec < 0)
> - {
> - --d.tv_sec;
> - d.tv_nsec += 1000000000;
> - }
> - if (d.tv_sec > 0
> - || d.tv_nsec < sleeptime.tv_nsec
> - || d.tv_nsec > sleeptime.tv_nsec * 2)
> + /* The bound values are empirically defined by testing this code over
> + high cpu usage and different nice values. Of all the values we keep
> + the 90th percentile of values and use those values for our testing
> + allowed range. */
> + diff = timespec_sub (support_timespec_normalize (afterns),
> + support_timespec_normalize (after));
> + if (!support_timespec_check_in_range (sleeptime, diff, .9, 1.2))
> {
> printf ("nanosleep time %ju.%.9ju outside reasonable range\n",
> - (uintmax_t) d.tv_sec, (uintmax_t) d.tv_nsec);
> + (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> result = 1;
> }
> }
> @@ -240,15 +234,13 @@ do_test (void)
> /* Should be close to 0.6. */
> printf ("dead PID %d => %ju.%.9ju\n",
> child, (uintmax_t) dead.tv_sec, (uintmax_t) dead.tv_nsec);
> -
> - diff.tv_sec = dead.tv_sec - after.tv_sec;
> - diff.tv_nsec = dead.tv_nsec - after.tv_nsec;
> - if (diff.tv_nsec < 0)
> - {
> - --diff.tv_sec;
> - diff.tv_nsec += 1000000000;
> - }
> - if (diff.tv_sec != 0 || diff.tv_nsec > 200000000)
> + /* The bound values are empirically defined by testing this code over high cpu
> + usage and different nice values. Of all the values we keep the 90th
> + percentile of values and use those values for our testing allowed range. */
> + diff = timespec_sub (support_timespec_normalize (dead),
> + support_timespec_normalize (after));
> + sleeptime.tv_nsec = 100000000;
> + if (!support_timespec_check_in_range (sleeptime, diff, .9, 1.2))
> {
> printf ("dead - after %ju.%.9ju outside reasonable range\n",
> (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> --
> 2.20.1
>
^ permalink raw reply [flat|nested] 44+ messages in thread* Re: [PATCH v9] Fix time/tst-cpuclock1 intermitent failures
2020-05-11 17:41 ` Lucas A. M. Magalhaes via Libc-alpha
@ 2020-05-25 11:46 ` Lucas A. M. Magalhaes via Libc-alpha
2020-06-08 13:58 ` Lucas A. M. Magalhaes via Libc-alpha
0 siblings, 1 reply; 44+ messages in thread
From: Lucas A. M. Magalhaes via Libc-alpha @ 2020-05-25 11:46 UTC (permalink / raw)
To: libc-alpha
PING
Quoting Lucas A. M. Magalhaes (2020-05-11 14:41:40)
> PING.
>
> Quoting Lucas A. M. Magalhaes via Libc-alpha (2020-04-21 14:44:56)
> > This test fails intermittently in systems with heavy load as
> > CLOCK_PROCESS_CPUTIME_ID is subject to scheduler pressure. Thus the
> > test boundaries were relaxed to keep it from failing on such systems.
> >
> > A refactor of the spent time checking was made with some support
> > functions. With the advantage to representing time jitter in percent
> > of the target.
> >
> > The values used by the test boundaries are all empirical.
> >
> > ---
> >
> > Hi Carlos,
> > I also got skeptical about my dataset so I genegerated another one.
> > That .4 boundry was indeed too low. Also, the support/tst-timespec was
> > not actually running any tests because of a lazy bug, sorry about that.
> > Thanks for taking the time for reviewing this.
> >
> > changes on V9:
> > Add new testcases
> > Fix support/tst-timespec do_run
> > Add comments
> > Change boundaries
> >
> > changes on V8:
> > Add support_timespec_ns
> > Add more tests
> >
> > This list of changes where getting to long.
> > ---
> > support/Makefile | 1 +
> > support/timespec.c | 64 +++++++++
> > support/timespec.h | 8 ++
> > support/tst-timespec.c | 320 +++++++++++++++++++++++++++++++++++++++++
> > time/tst-cpuclock1.c | 52 +++----
> > 5 files changed, 415 insertions(+), 30 deletions(-)
> > create mode 100644 support/tst-timespec.c
> >
> > diff --git a/support/Makefile b/support/Makefile
> > index 6e38b87ebe..cacaac96a5 100644
> > --- a/support/Makefile
> > +++ b/support/Makefile
> > @@ -233,6 +233,7 @@ tests = \
> > tst-test_compare \
> > tst-test_compare_blob \
> > tst-test_compare_string \
> > + tst-timespec \
> > tst-xreadlink \
> > tst-xsigstack \
> >
> > diff --git a/support/timespec.c b/support/timespec.c
> > index ea6b947546..103beafdc4 100644
> > --- a/support/timespec.c
> > +++ b/support/timespec.c
> > @@ -19,6 +19,8 @@
> > #include <support/timespec.h>
> > #include <stdio.h>
> > #include <stdint.h>
> > +#include <assert.h>
> > +#include <intprops.h>
> >
> > void
> > test_timespec_before_impl (const char *file, int line,
> > @@ -57,3 +59,65 @@ test_timespec_equal_or_after_impl (const char *file, int line,
> > (intmax_t) diff.tv_sec, (intmax_t) diff.tv_nsec);
> > }
> > }
> > +
> > +/* Convert TIME to nanoseconds stored in shrinked in a long.
> > + Returns long maximum or minimum if the conversion overflows
> > + or underflows, respectively. */
> > +long
> > +support_timespec_ns (struct timespec time)
> > +{
> > + long time_ns;
> > + if (INT_MULTIPLY_WRAPV(time.tv_sec, TIMESPEC_HZ, &time_ns))
> > + {
> > + return (time.tv_sec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long);
> > + }
> > + if (INT_ADD_WRAPV(time_ns, time.tv_nsec, &time_ns))
> > + {
> > + return (time.tv_nsec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long);
> > + }
> > + return time_ns;
> > +}
> > +
> > +/* Returns t normalized timespec with .tv_nsec < TIMESPEC_HZ
> > + and the whole seconds added to .tv_sec. If an overflow or
> > + underflow occurs the values are clamped to its maximum or
> > + minimum respectively. */
> > +struct timespec
> > +support_timespec_normalize (struct timespec time)
> > +{
> > + struct timespec norm;
> > + if (INT_ADD_WRAPV (time.tv_sec, (time.tv_nsec / TIMESPEC_HZ), &norm.tv_sec))
> > + {
> > + norm.tv_sec = (time.tv_nsec < 0) ? TYPE_MINIMUM (time_t): TYPE_MAXIMUM (time_t);
> > + norm.tv_nsec = (time.tv_nsec < 0) ? -1 * (TIMESPEC_HZ - 1) : TIMESPEC_HZ - 1;
> > + return norm;
> > + }
> > + norm.tv_nsec = time.tv_nsec % TIMESPEC_HZ;
> > + return norm;
> > +}
> > +
> > +/* Returns TRUE if the observed time is within the given percentage
> > + bounds of the expected time, and FALSE otherwise.
> > + For example the call
> > +
> > + support_timespec_check_in_range(expected, observed, .5, 1.2);
> > +
> > + will check if
> > +
> > + .5 <= observed/expected <= 1.2
> > +
> > + In other words it will check if observed time is within 50% to
> > + 120% of the expected time. */
> > +int
> > +support_timespec_check_in_range (struct timespec expected, struct timespec observed,
> > + double lower_bound, double upper_bound)
> > +{
> > + assert (upper_bound >= lower_bound);
> > + long expected_norm, observed_norm;
> > + expected_norm = support_timespec_ns (expected);
> > + /* Don't divide by zero */
> > + assert(expected_norm != 0);
> > + observed_norm = support_timespec_ns (observed);
> > + double ratio = (double)observed_norm / expected_norm;
> > + return (lower_bound <= ratio && ratio <= upper_bound);
> > +}
> > diff --git a/support/timespec.h b/support/timespec.h
> > index c5852dfe75..fd5466745d 100644
> > --- a/support/timespec.h
> > +++ b/support/timespec.h
> > @@ -48,6 +48,14 @@ void test_timespec_equal_or_after_impl (const char *file, int line,
> > const struct timespec left,
> > const struct timespec right);
> >
> > +long support_timespec_ns (struct timespec time);
> > +
> > +struct timespec support_timespec_normalize (struct timespec time);
> > +
> > +int support_timespec_check_in_range (struct timespec expected, struct timespec observed,
> > + double lower_bound, double upper_bound);
> > +
> > +
> > /* Check that the timespec on the left represents a time before the
> > time on the right. */
> > #define TEST_TIMESPEC_BEFORE(left, right) \
> > diff --git a/support/tst-timespec.c b/support/tst-timespec.c
> > new file mode 100644
> > index 0000000000..b421b219fd
> > --- /dev/null
> > +++ b/support/tst-timespec.c
> > @@ -0,0 +1,320 @@
> > +/* Test for support_timespec_check_in_range function.
> > + Copyright (C) 2020 Free Software Foundation, Inc.
> > + This file is part of the GNU C Library.
> > +
> > + The GNU C Library is free software; you can redistribute it and/or
> > + modify it under the terms of the GNU Lesser General Public
> > + License as published by the Free Software Foundation; either
> > + version 2.1 of the License, or (at your option) any later version.
> > +
> > + The GNU C Library is distributed in the hope that it will be useful,
> > + but WITHOUT ANY WARRANTY; without even the implied warranty of
> > + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> > + Lesser General Public License for more details.
> > +
> > + You should have received a copy of the GNU Lesser General Public
> > + License along with the GNU C Library; if not, see
> > + <https://www.gnu.org/licenses/>. */
> > +
> > +#include <support/timespec.h>
> > +#include <support/check.h>
> > +#include <limits.h>
> > +
> > +#define TIMESPEC_HZ 1000000000
> > +
> > +struct timespec_ns_test_case
> > +{
> > + struct timespec time;
> > + long time_ns;
> > +};
> > +
> > +struct timespec_norm_test_case
> > +{
> > + struct timespec time;
> > + struct timespec norm;
> > +};
> > +
> > +struct timespec_test_case
> > +{
> > + struct timespec expected;
> > + struct timespec observed;
> > + double upper_bound;
> > + double lower_bound;
> > + int result;
> > +};
> > +
> > +/* Test cases for timespec_ns */
> > +struct timespec_ns_test_case ns_cases[] = {
> > + {.time = {.tv_sec = 0, .tv_nsec = 0},
> > + .time_ns = 0,
> > + },
> > + {.time = {.tv_sec = 0, .tv_nsec = 1},
> > + .time_ns = 1,
> > + },
> > + {.time = {.tv_sec = 1, .tv_nsec = 0},
> > + .time_ns = TIMESPEC_HZ,
> > + },
> > + {.time = {.tv_sec = 1, .tv_nsec = 1},
> > + .time_ns = TIMESPEC_HZ + 1,
> > + },
> > + {.time = {.tv_sec = 0, .tv_nsec = -1},
> > + .time_ns = -1,
> > + },
> > + {.time = {.tv_sec = -1, .tv_nsec = 0},
> > + .time_ns = -TIMESPEC_HZ,
> > + },
> > + {.time = {.tv_sec = -1, .tv_nsec = -1},
> > + .time_ns = -TIMESPEC_HZ - 1,
> > + },
> > + {.time = {.tv_sec = 1, .tv_nsec = -1},
> > + .time_ns = TIMESPEC_HZ - 1,
> > + },
> > + {.time = {.tv_sec = -1, .tv_nsec = 1},
> > + .time_ns = -TIMESPEC_HZ + 1,
> > + },
> > + // Overflow bondary by 2
> > + {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ, .tv_nsec = LONG_MAX%TIMESPEC_HZ - 1},
> > + .time_ns = LONG_MAX - 1,
> > + },
> > + // Overflow bondary
> > + {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ, .tv_nsec = LONG_MAX%TIMESPEC_HZ},
> > + .time_ns = LONG_MAX,
> > + },
> > + // Underflow bondary by 1
> > + {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ, .tv_nsec = LONG_MIN%TIMESPEC_HZ + 1},
> > + .time_ns = LONG_MIN + 1,
> > + },
> > + // Underflow bondary
> > + {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ, .tv_nsec = LONG_MIN%TIMESPEC_HZ},
> > + .time_ns = LONG_MIN,
> > + },
> > + // Multiplication overflow
> > + {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ + 1, .tv_nsec = 1},
> > + .time_ns = LONG_MAX,
> > + },
> > + // Multiplication underflow
> > + {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ - 1, .tv_nsec = -1},
> > + .time_ns = LONG_MIN,
> > + },
> > + // Sum overflows
> > + {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ, .tv_nsec = LONG_MAX%TIMESPEC_HZ + 1},
> > + .time_ns = LONG_MAX,
> > + },
> > + // Sum underflow
> > + {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ, .tv_nsec = LONG_MIN%TIMESPEC_HZ - 1},
> > + .time_ns = LONG_MIN,
> > + }
> > +};
> > +
> > +/* Test cases for timespec_norm */
> > +struct timespec_norm_test_case norm_cases[] = {
> > + // Positive cases
> > + {.time = {.tv_sec = 0, .tv_nsec = 0},
> > + .norm = {.tv_sec = 0, .tv_nsec = 0}
> > + },
> > + {.time = {.tv_sec = 1, .tv_nsec = 0},
> > + .norm = {.tv_sec = 1, .tv_nsec = 0}
> > + },
> > + {.time = {.tv_sec = 0, .tv_nsec = 1},
> > + .norm = {.tv_sec = 0, .tv_nsec = 1}
> > + },
> > + {.time = {.tv_sec = 0, .tv_nsec = TIMESPEC_HZ},
> > + .norm = {.tv_sec = 1, .tv_nsec = 0}
> > + },
> > + {.time = {.tv_sec = 0, .tv_nsec = TIMESPEC_HZ + 1},
> > + .norm = {.tv_sec = 1, .tv_nsec = 1}
> > + },
> > + {.time = {.tv_sec = 1, .tv_nsec = TIMESPEC_HZ},
> > + .norm = {.tv_sec = 2, .tv_nsec = 0}
> > + },
> > + {.time = {.tv_sec = 1, .tv_nsec = TIMESPEC_HZ + 1},
> > + .norm = {.tv_sec = 2, .tv_nsec = 1}
> > + },
> > + // Negative cases
> > + {.time = {.tv_sec = 0, .tv_nsec = -TIMESPEC_HZ},
> > + .norm = {.tv_sec = -1, .tv_nsec = 0}
> > + },
> > + {.time = {.tv_sec = 0, .tv_nsec = -TIMESPEC_HZ - 1},
> > + .norm = {.tv_sec = -1, .tv_nsec = -1}
> > + },
> > + {.time = {.tv_sec = -1, .tv_nsec = -TIMESPEC_HZ},
> > + .norm = {.tv_sec = -2, .tv_nsec = 0}
> > + },
> > + {.time = {.tv_sec = -1, .tv_nsec = -TIMESPEC_HZ - 1},
> > + .norm = {.tv_sec = -2, .tv_nsec = -1}
> > + },
> > + // Overflow bondary by 2
> > + {.time = {.tv_sec = LONG_MAX - 2, .tv_nsec = TIMESPEC_HZ + 1},
> > + .norm = {.tv_sec = LONG_MAX - 1, 1},
> > + },
> > + // Overflow bondary by 1
> > + {.time = {.tv_sec = LONG_MAX - 1, .tv_nsec = TIMESPEC_HZ + 1},
> > + .norm = {.tv_sec = LONG_MAX, .tv_nsec = 1},
> > + },
> > + // Underflow bondary by 2
> > + {.time = {.tv_sec = LONG_MIN + 2, .tv_nsec = -TIMESPEC_HZ - 1},
> > + .norm = {.tv_sec = LONG_MIN + 1, -1},
> > + },
> > + // Underflow bondary by 1
> > + {.time = {.tv_sec = LONG_MIN + 1, .tv_nsec = -TIMESPEC_HZ - 1},
> > + .norm = {.tv_sec = LONG_MIN, .tv_nsec = -1},
> > + },
> > + // SUM overflow
> > + {.time = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> > + .norm = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ - 1},
> > + },
> > + // SUM underflow
> > + {.time = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> > + .norm = {.tv_sec = LONG_MIN, .tv_nsec = -1 * (TIMESPEC_HZ - 1)},
> > + }
> > +};
> > +
> > +/* Test cases for timespec_check_in_range */
> > +struct timespec_test_case check_cases[] = {
> > + // 0 - In range
> > + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> > + .observed = {.tv_sec = 1, .tv_nsec = 0},
> > + .upper_bound = 1, .lower_bound = 1, .result = 1,
> > + },
> > + // 1 - Out of range
> > + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> > + .observed = {.tv_sec = 2, .tv_nsec = 0},
> > + .upper_bound = 1, .lower_bound = 1, .result = 0,
> > + },
> > + // 2 - Upper Bound
> > + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> > + .observed = {.tv_sec = 2, .tv_nsec = 0},
> > + .upper_bound = 2, .lower_bound = 1, .result = 1,
> > + },
> > + // 3 - Lower Bound
> > + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> > + .observed = {.tv_sec = 0, .tv_nsec = 0},
> > + .upper_bound = 1, .lower_bound = 0, .result = 1,
> > + },
> > + // 4 - Out of range by nanosecs
> > + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> > + .observed = {.tv_sec = 1, .tv_nsec = 500},
> > + .upper_bound = 1, .lower_bound = 1, .result = 0,
> > + },
> > + // 5 - In range by nanosecs
> > + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> > + .observed = {.tv_sec = 1, .tv_nsec = 50000},
> > + .upper_bound = 1.3, .lower_bound = 1, .result = 1,
> > + },
> > + // 6 - Big nanosecs
> > + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> > + .observed = {.tv_sec = 0, .tv_nsec = 4000000},
> > + .upper_bound = 1, .lower_bound = .001, .result = 1,
> > + },
> > + // 7 - In range Negative values
> > + {.expected = {.tv_sec = -1, .tv_nsec = 0},
> > + .observed = {.tv_sec = -1, .tv_nsec = 0},
> > + .upper_bound = 1, .lower_bound = 1, .result = 1,
> > + },
> > + // 8 - Out of range Negative values
> > + {.expected = {.tv_sec = -1, .tv_nsec = 0},
> > + .observed = {.tv_sec = -1, .tv_nsec = 0},
> > + .upper_bound = -1, .lower_bound = -1, .result = 0,
> > + },
> > + // 9 - Negative values with negative nanosecs
> > + {.expected = {.tv_sec = -1, .tv_nsec = 0},
> > + .observed = {.tv_sec = -1, .tv_nsec = -2000},
> > + .upper_bound = 1, .lower_bound = 1, .result = 0,
> > + },
> > + // 10 - Strict bounds
> > + {.expected = {.tv_sec = -1, .tv_nsec = 0},
> > + .observed = {.tv_sec = -1, .tv_nsec = -20000},
> > + .upper_bound = 1.00002, .lower_bound = 1.0000191, .result = 1,
> > + },
> > + // 11 - Strict bounds with loose upper bound
> > + {.expected = {.tv_sec = 1, .tv_nsec = 20000},
> > + .observed = {.tv_sec = 1, .tv_nsec = 30000},
> > + .upper_bound = 1.0000100000, .lower_bound = 1.0000099998, .result = 1,
> > + },
> > + // 12 - Strict bounds with loose lower bound
> > + {.expected = {.tv_sec = 1, .tv_nsec = 20000},
> > + .observed = {.tv_sec = 1, .tv_nsec = 30000},
> > + .upper_bound = 1.0000099999, .lower_bound = 1.00000999979, .result = 1,
> > + },
> > + // 13 - Strict bounds highest precision
> > + {.expected = {.tv_sec = 1, .tv_nsec = 20000},
> > + .observed = {.tv_sec = 1, .tv_nsec = 30000},
> > + .upper_bound = 1.00000999980001, .lower_bound = 1.00000999979999, .result = 1,
> > + },
> > + /* Maximum/Minimum long values */
> > + // 14
> > + {.expected = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ - 1},
> > + .observed = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ - 2},
> > + .upper_bound = 1, .lower_bound = .9, .result = 1,
> > + },
> > + // 15 - support_timespec_ns overflow
> > + {.expected = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> > + .observed = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> > + .upper_bound = 1, .lower_bound = 1, .result = 1,
> > + },
> > + // 16 - support_timespec_ns overflow + underflow
> > + {.expected = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> > + .observed = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> > + .upper_bound = 1, .lower_bound = 1, .result = 0,
> > + },
> > + // 17 - support_timespec_ns underflow
> > + {.expected = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> > + .observed = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> > + .upper_bound = 1, .lower_bound = 1, .result = 1,
> > + },
> > + // 18 - support_timespec_ns underflow + overflow
> > + {.expected = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> > + .observed = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> > + .upper_bound = 1, .lower_bound = 1, .result = 0,
> > + },
> > + // 19 - Biggest division
> > + {.expected = {.tv_sec = LONG_MAX / TIMESPEC_HZ , .tv_nsec = TIMESPEC_HZ - 1},
> > + .observed = {.tv_sec = 0, .tv_nsec = 1},
> > + .upper_bound = 1, .lower_bound = 1.0842021724855044e-19, .result = 1,
> > + },
> > + // 20 - Lowest division
> > + {.expected = {.tv_sec = 0, .tv_nsec = 1},
> > + .observed = {.tv_sec = LONG_MAX / TIMESPEC_HZ , .tv_nsec = TIMESPEC_HZ - 1},
> > + .upper_bound = LONG_MAX, .lower_bound = 1, .result = 1,
> > + },
> > +};
> > +
> > +static int
> > +do_test (void)
> > +{
> > + int i = 0;
> > + int ntests = sizeof (ns_cases) / sizeof (ns_cases[0]);
> > +
> > + printf("Testing support_timespec_ns\n");
> > + for (i = 0; i < ntests; i++)
> > + {
> > + TEST_COMPARE (support_timespec_ns (ns_cases[i].time),
> > + ns_cases[i].time_ns);
> > + }
> > +
> > + ntests = sizeof (norm_cases) / sizeof (norm_cases[0]);
> > + struct timespec result;
> > + printf("Testing support_timespec_normalize\n");
> > + for (i = 0; i < ntests; i++)
> > + {
> > + result = support_timespec_normalize (norm_cases[i].time);
> > + TEST_COMPARE (norm_cases[i].norm.tv_sec, result.tv_sec);
> > + TEST_COMPARE (norm_cases[i].norm.tv_nsec, result.tv_nsec);
> > + }
> > +
> > + ntests = sizeof (check_cases) / sizeof (check_cases[0]);
> > + printf("Testing support_timespec_check_in_range\n");
> > + for (i = 0; i < ntests; i++)
> > + {
> > + /* Its hard to find which test failed with just the TEST_COMPARE report.
> > + So here we print every running testcase as well. */
> > + printf("Test case %d\n", i);
> > + TEST_COMPARE (support_timespec_check_in_range
> > + (check_cases[i].expected, check_cases[i].observed,
> > + check_cases[i].lower_bound,
> > + check_cases[i].upper_bound), check_cases[i].result);
> > + }
> > + return 0;
> > +}
> > +
> > +#include <support/test-driver.c>
> > diff --git a/time/tst-cpuclock1.c b/time/tst-cpuclock1.c
> > index 0120906f23..1ac611a92b 100644
> > --- a/time/tst-cpuclock1.c
> > +++ b/time/tst-cpuclock1.c
> > @@ -26,6 +26,7 @@
> > #include <signal.h>
> > #include <stdint.h>
> > #include <sys/wait.h>
> > +#include <support/timespec.h>
> >
> > /* This function is intended to rack up both user and system time. */
> > static void
> > @@ -155,16 +156,12 @@ do_test (void)
> > printf ("live PID %d after sleep => %ju.%.9ju\n",
> > child, (uintmax_t) after.tv_sec, (uintmax_t) after.tv_nsec);
> >
> > - struct timespec diff = { .tv_sec = after.tv_sec - before.tv_sec,
> > - .tv_nsec = after.tv_nsec - before.tv_nsec };
> > - if (diff.tv_nsec < 0)
> > - {
> > - --diff.tv_sec;
> > - diff.tv_nsec += 1000000000;
> > - }
> > - if (diff.tv_sec != 0
> > - || diff.tv_nsec > 600000000
> > - || diff.tv_nsec < 100000000)
> > + /* The bound values are empirically defined by testing this code over high cpu
> > + usage and different nice values. Of all the values we keep the 90th
> > + percentile of values and use those values for our testing allowed range. */
> > + struct timespec diff = timespec_sub (support_timespec_normalize (after),
> > + support_timespec_normalize (before));
> > + if (!support_timespec_check_in_range (sleeptime, diff, .9, 1.1))
> > {
> > printf ("before - after %ju.%.9ju outside reasonable range\n",
> > (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> > @@ -194,19 +191,16 @@ do_test (void)
> > }
> > else
> > {
> > - struct timespec d = { .tv_sec = afterns.tv_sec - after.tv_sec,
> > - .tv_nsec = afterns.tv_nsec - after.tv_nsec };
> > - if (d.tv_nsec < 0)
> > - {
> > - --d.tv_sec;
> > - d.tv_nsec += 1000000000;
> > - }
> > - if (d.tv_sec > 0
> > - || d.tv_nsec < sleeptime.tv_nsec
> > - || d.tv_nsec > sleeptime.tv_nsec * 2)
> > + /* The bound values are empirically defined by testing this code over
> > + high cpu usage and different nice values. Of all the values we keep
> > + the 90th percentile of values and use those values for our testing
> > + allowed range. */
> > + diff = timespec_sub (support_timespec_normalize (afterns),
> > + support_timespec_normalize (after));
> > + if (!support_timespec_check_in_range (sleeptime, diff, .9, 1.2))
> > {
> > printf ("nanosleep time %ju.%.9ju outside reasonable range\n",
> > - (uintmax_t) d.tv_sec, (uintmax_t) d.tv_nsec);
> > + (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> > result = 1;
> > }
> > }
> > @@ -240,15 +234,13 @@ do_test (void)
> > /* Should be close to 0.6. */
> > printf ("dead PID %d => %ju.%.9ju\n",
> > child, (uintmax_t) dead.tv_sec, (uintmax_t) dead.tv_nsec);
> > -
> > - diff.tv_sec = dead.tv_sec - after.tv_sec;
> > - diff.tv_nsec = dead.tv_nsec - after.tv_nsec;
> > - if (diff.tv_nsec < 0)
> > - {
> > - --diff.tv_sec;
> > - diff.tv_nsec += 1000000000;
> > - }
> > - if (diff.tv_sec != 0 || diff.tv_nsec > 200000000)
> > + /* The bound values are empirically defined by testing this code over high cpu
> > + usage and different nice values. Of all the values we keep the 90th
> > + percentile of values and use those values for our testing allowed range. */
> > + diff = timespec_sub (support_timespec_normalize (dead),
> > + support_timespec_normalize (after));
> > + sleeptime.tv_nsec = 100000000;
> > + if (!support_timespec_check_in_range (sleeptime, diff, .9, 1.2))
> > {
> > printf ("dead - after %ju.%.9ju outside reasonable range\n",
> > (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> > --
> > 2.20.1
> >
^ permalink raw reply [flat|nested] 44+ messages in thread* Re: [PATCH v9] Fix time/tst-cpuclock1 intermitent failures
2020-05-25 11:46 ` Lucas A. M. Magalhaes via Libc-alpha
@ 2020-06-08 13:58 ` Lucas A. M. Magalhaes via Libc-alpha
0 siblings, 0 replies; 44+ messages in thread
From: Lucas A. M. Magalhaes via Libc-alpha @ 2020-06-08 13:58 UTC (permalink / raw)
To: libc-alpha
PING
Quoting Lucas A. M. Magalhaes (2020-05-25 08:46:50)
> PING
>
> Quoting Lucas A. M. Magalhaes (2020-05-11 14:41:40)
> > PING.
> >
> > Quoting Lucas A. M. Magalhaes via Libc-alpha (2020-04-21 14:44:56)
> > > This test fails intermittently in systems with heavy load as
> > > CLOCK_PROCESS_CPUTIME_ID is subject to scheduler pressure. Thus the
> > > test boundaries were relaxed to keep it from failing on such systems.
> > >
> > > A refactor of the spent time checking was made with some support
> > > functions. With the advantage to representing time jitter in percent
> > > of the target.
> > >
> > > The values used by the test boundaries are all empirical.
> > >
> > > ---
> > >
> > > Hi Carlos,
> > > I also got skeptical about my dataset so I genegerated another one.
> > > That .4 boundry was indeed too low. Also, the support/tst-timespec was
> > > not actually running any tests because of a lazy bug, sorry about that.
> > > Thanks for taking the time for reviewing this.
> > >
> > > changes on V9:
> > > Add new testcases
> > > Fix support/tst-timespec do_run
> > > Add comments
> > > Change boundaries
> > >
> > > changes on V8:
> > > Add support_timespec_ns
> > > Add more tests
> > >
> > > This list of changes where getting to long.
> > > ---
> > > support/Makefile | 1 +
> > > support/timespec.c | 64 +++++++++
> > > support/timespec.h | 8 ++
> > > support/tst-timespec.c | 320 +++++++++++++++++++++++++++++++++++++++++
> > > time/tst-cpuclock1.c | 52 +++----
> > > 5 files changed, 415 insertions(+), 30 deletions(-)
> > > create mode 100644 support/tst-timespec.c
> > >
> > > diff --git a/support/Makefile b/support/Makefile
> > > index 6e38b87ebe..cacaac96a5 100644
> > > --- a/support/Makefile
> > > +++ b/support/Makefile
> > > @@ -233,6 +233,7 @@ tests = \
> > > tst-test_compare \
> > > tst-test_compare_blob \
> > > tst-test_compare_string \
> > > + tst-timespec \
> > > tst-xreadlink \
> > > tst-xsigstack \
> > >
> > > diff --git a/support/timespec.c b/support/timespec.c
> > > index ea6b947546..103beafdc4 100644
> > > --- a/support/timespec.c
> > > +++ b/support/timespec.c
> > > @@ -19,6 +19,8 @@
> > > #include <support/timespec.h>
> > > #include <stdio.h>
> > > #include <stdint.h>
> > > +#include <assert.h>
> > > +#include <intprops.h>
> > >
> > > void
> > > test_timespec_before_impl (const char *file, int line,
> > > @@ -57,3 +59,65 @@ test_timespec_equal_or_after_impl (const char *file, int line,
> > > (intmax_t) diff.tv_sec, (intmax_t) diff.tv_nsec);
> > > }
> > > }
> > > +
> > > +/* Convert TIME to nanoseconds stored in shrinked in a long.
> > > + Returns long maximum or minimum if the conversion overflows
> > > + or underflows, respectively. */
> > > +long
> > > +support_timespec_ns (struct timespec time)
> > > +{
> > > + long time_ns;
> > > + if (INT_MULTIPLY_WRAPV(time.tv_sec, TIMESPEC_HZ, &time_ns))
> > > + {
> > > + return (time.tv_sec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long);
> > > + }
> > > + if (INT_ADD_WRAPV(time_ns, time.tv_nsec, &time_ns))
> > > + {
> > > + return (time.tv_nsec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long);
> > > + }
> > > + return time_ns;
> > > +}
> > > +
> > > +/* Returns t normalized timespec with .tv_nsec < TIMESPEC_HZ
> > > + and the whole seconds added to .tv_sec. If an overflow or
> > > + underflow occurs the values are clamped to its maximum or
> > > + minimum respectively. */
> > > +struct timespec
> > > +support_timespec_normalize (struct timespec time)
> > > +{
> > > + struct timespec norm;
> > > + if (INT_ADD_WRAPV (time.tv_sec, (time.tv_nsec / TIMESPEC_HZ), &norm.tv_sec))
> > > + {
> > > + norm.tv_sec = (time.tv_nsec < 0) ? TYPE_MINIMUM (time_t): TYPE_MAXIMUM (time_t);
> > > + norm.tv_nsec = (time.tv_nsec < 0) ? -1 * (TIMESPEC_HZ - 1) : TIMESPEC_HZ - 1;
> > > + return norm;
> > > + }
> > > + norm.tv_nsec = time.tv_nsec % TIMESPEC_HZ;
> > > + return norm;
> > > +}
> > > +
> > > +/* Returns TRUE if the observed time is within the given percentage
> > > + bounds of the expected time, and FALSE otherwise.
> > > + For example the call
> > > +
> > > + support_timespec_check_in_range(expected, observed, .5, 1.2);
> > > +
> > > + will check if
> > > +
> > > + .5 <= observed/expected <= 1.2
> > > +
> > > + In other words it will check if observed time is within 50% to
> > > + 120% of the expected time. */
> > > +int
> > > +support_timespec_check_in_range (struct timespec expected, struct timespec observed,
> > > + double lower_bound, double upper_bound)
> > > +{
> > > + assert (upper_bound >= lower_bound);
> > > + long expected_norm, observed_norm;
> > > + expected_norm = support_timespec_ns (expected);
> > > + /* Don't divide by zero */
> > > + assert(expected_norm != 0);
> > > + observed_norm = support_timespec_ns (observed);
> > > + double ratio = (double)observed_norm / expected_norm;
> > > + return (lower_bound <= ratio && ratio <= upper_bound);
> > > +}
> > > diff --git a/support/timespec.h b/support/timespec.h
> > > index c5852dfe75..fd5466745d 100644
> > > --- a/support/timespec.h
> > > +++ b/support/timespec.h
> > > @@ -48,6 +48,14 @@ void test_timespec_equal_or_after_impl (const char *file, int line,
> > > const struct timespec left,
> > > const struct timespec right);
> > >
> > > +long support_timespec_ns (struct timespec time);
> > > +
> > > +struct timespec support_timespec_normalize (struct timespec time);
> > > +
> > > +int support_timespec_check_in_range (struct timespec expected, struct timespec observed,
> > > + double lower_bound, double upper_bound);
> > > +
> > > +
> > > /* Check that the timespec on the left represents a time before the
> > > time on the right. */
> > > #define TEST_TIMESPEC_BEFORE(left, right) \
> > > diff --git a/support/tst-timespec.c b/support/tst-timespec.c
> > > new file mode 100644
> > > index 0000000000..b421b219fd
> > > --- /dev/null
> > > +++ b/support/tst-timespec.c
> > > @@ -0,0 +1,320 @@
> > > +/* Test for support_timespec_check_in_range function.
> > > + Copyright (C) 2020 Free Software Foundation, Inc.
> > > + This file is part of the GNU C Library.
> > > +
> > > + The GNU C Library is free software; you can redistribute it and/or
> > > + modify it under the terms of the GNU Lesser General Public
> > > + License as published by the Free Software Foundation; either
> > > + version 2.1 of the License, or (at your option) any later version.
> > > +
> > > + The GNU C Library is distributed in the hope that it will be useful,
> > > + but WITHOUT ANY WARRANTY; without even the implied warranty of
> > > + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> > > + Lesser General Public License for more details.
> > > +
> > > + You should have received a copy of the GNU Lesser General Public
> > > + License along with the GNU C Library; if not, see
> > > + <https://www.gnu.org/licenses/>. */
> > > +
> > > +#include <support/timespec.h>
> > > +#include <support/check.h>
> > > +#include <limits.h>
> > > +
> > > +#define TIMESPEC_HZ 1000000000
> > > +
> > > +struct timespec_ns_test_case
> > > +{
> > > + struct timespec time;
> > > + long time_ns;
> > > +};
> > > +
> > > +struct timespec_norm_test_case
> > > +{
> > > + struct timespec time;
> > > + struct timespec norm;
> > > +};
> > > +
> > > +struct timespec_test_case
> > > +{
> > > + struct timespec expected;
> > > + struct timespec observed;
> > > + double upper_bound;
> > > + double lower_bound;
> > > + int result;
> > > +};
> > > +
> > > +/* Test cases for timespec_ns */
> > > +struct timespec_ns_test_case ns_cases[] = {
> > > + {.time = {.tv_sec = 0, .tv_nsec = 0},
> > > + .time_ns = 0,
> > > + },
> > > + {.time = {.tv_sec = 0, .tv_nsec = 1},
> > > + .time_ns = 1,
> > > + },
> > > + {.time = {.tv_sec = 1, .tv_nsec = 0},
> > > + .time_ns = TIMESPEC_HZ,
> > > + },
> > > + {.time = {.tv_sec = 1, .tv_nsec = 1},
> > > + .time_ns = TIMESPEC_HZ + 1,
> > > + },
> > > + {.time = {.tv_sec = 0, .tv_nsec = -1},
> > > + .time_ns = -1,
> > > + },
> > > + {.time = {.tv_sec = -1, .tv_nsec = 0},
> > > + .time_ns = -TIMESPEC_HZ,
> > > + },
> > > + {.time = {.tv_sec = -1, .tv_nsec = -1},
> > > + .time_ns = -TIMESPEC_HZ - 1,
> > > + },
> > > + {.time = {.tv_sec = 1, .tv_nsec = -1},
> > > + .time_ns = TIMESPEC_HZ - 1,
> > > + },
> > > + {.time = {.tv_sec = -1, .tv_nsec = 1},
> > > + .time_ns = -TIMESPEC_HZ + 1,
> > > + },
> > > + // Overflow bondary by 2
> > > + {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ, .tv_nsec = LONG_MAX%TIMESPEC_HZ - 1},
> > > + .time_ns = LONG_MAX - 1,
> > > + },
> > > + // Overflow bondary
> > > + {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ, .tv_nsec = LONG_MAX%TIMESPEC_HZ},
> > > + .time_ns = LONG_MAX,
> > > + },
> > > + // Underflow bondary by 1
> > > + {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ, .tv_nsec = LONG_MIN%TIMESPEC_HZ + 1},
> > > + .time_ns = LONG_MIN + 1,
> > > + },
> > > + // Underflow bondary
> > > + {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ, .tv_nsec = LONG_MIN%TIMESPEC_HZ},
> > > + .time_ns = LONG_MIN,
> > > + },
> > > + // Multiplication overflow
> > > + {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ + 1, .tv_nsec = 1},
> > > + .time_ns = LONG_MAX,
> > > + },
> > > + // Multiplication underflow
> > > + {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ - 1, .tv_nsec = -1},
> > > + .time_ns = LONG_MIN,
> > > + },
> > > + // Sum overflows
> > > + {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ, .tv_nsec = LONG_MAX%TIMESPEC_HZ + 1},
> > > + .time_ns = LONG_MAX,
> > > + },
> > > + // Sum underflow
> > > + {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ, .tv_nsec = LONG_MIN%TIMESPEC_HZ - 1},
> > > + .time_ns = LONG_MIN,
> > > + }
> > > +};
> > > +
> > > +/* Test cases for timespec_norm */
> > > +struct timespec_norm_test_case norm_cases[] = {
> > > + // Positive cases
> > > + {.time = {.tv_sec = 0, .tv_nsec = 0},
> > > + .norm = {.tv_sec = 0, .tv_nsec = 0}
> > > + },
> > > + {.time = {.tv_sec = 1, .tv_nsec = 0},
> > > + .norm = {.tv_sec = 1, .tv_nsec = 0}
> > > + },
> > > + {.time = {.tv_sec = 0, .tv_nsec = 1},
> > > + .norm = {.tv_sec = 0, .tv_nsec = 1}
> > > + },
> > > + {.time = {.tv_sec = 0, .tv_nsec = TIMESPEC_HZ},
> > > + .norm = {.tv_sec = 1, .tv_nsec = 0}
> > > + },
> > > + {.time = {.tv_sec = 0, .tv_nsec = TIMESPEC_HZ + 1},
> > > + .norm = {.tv_sec = 1, .tv_nsec = 1}
> > > + },
> > > + {.time = {.tv_sec = 1, .tv_nsec = TIMESPEC_HZ},
> > > + .norm = {.tv_sec = 2, .tv_nsec = 0}
> > > + },
> > > + {.time = {.tv_sec = 1, .tv_nsec = TIMESPEC_HZ + 1},
> > > + .norm = {.tv_sec = 2, .tv_nsec = 1}
> > > + },
> > > + // Negative cases
> > > + {.time = {.tv_sec = 0, .tv_nsec = -TIMESPEC_HZ},
> > > + .norm = {.tv_sec = -1, .tv_nsec = 0}
> > > + },
> > > + {.time = {.tv_sec = 0, .tv_nsec = -TIMESPEC_HZ - 1},
> > > + .norm = {.tv_sec = -1, .tv_nsec = -1}
> > > + },
> > > + {.time = {.tv_sec = -1, .tv_nsec = -TIMESPEC_HZ},
> > > + .norm = {.tv_sec = -2, .tv_nsec = 0}
> > > + },
> > > + {.time = {.tv_sec = -1, .tv_nsec = -TIMESPEC_HZ - 1},
> > > + .norm = {.tv_sec = -2, .tv_nsec = -1}
> > > + },
> > > + // Overflow bondary by 2
> > > + {.time = {.tv_sec = LONG_MAX - 2, .tv_nsec = TIMESPEC_HZ + 1},
> > > + .norm = {.tv_sec = LONG_MAX - 1, 1},
> > > + },
> > > + // Overflow bondary by 1
> > > + {.time = {.tv_sec = LONG_MAX - 1, .tv_nsec = TIMESPEC_HZ + 1},
> > > + .norm = {.tv_sec = LONG_MAX, .tv_nsec = 1},
> > > + },
> > > + // Underflow bondary by 2
> > > + {.time = {.tv_sec = LONG_MIN + 2, .tv_nsec = -TIMESPEC_HZ - 1},
> > > + .norm = {.tv_sec = LONG_MIN + 1, -1},
> > > + },
> > > + // Underflow bondary by 1
> > > + {.time = {.tv_sec = LONG_MIN + 1, .tv_nsec = -TIMESPEC_HZ - 1},
> > > + .norm = {.tv_sec = LONG_MIN, .tv_nsec = -1},
> > > + },
> > > + // SUM overflow
> > > + {.time = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> > > + .norm = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ - 1},
> > > + },
> > > + // SUM underflow
> > > + {.time = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> > > + .norm = {.tv_sec = LONG_MIN, .tv_nsec = -1 * (TIMESPEC_HZ - 1)},
> > > + }
> > > +};
> > > +
> > > +/* Test cases for timespec_check_in_range */
> > > +struct timespec_test_case check_cases[] = {
> > > + // 0 - In range
> > > + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> > > + .observed = {.tv_sec = 1, .tv_nsec = 0},
> > > + .upper_bound = 1, .lower_bound = 1, .result = 1,
> > > + },
> > > + // 1 - Out of range
> > > + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> > > + .observed = {.tv_sec = 2, .tv_nsec = 0},
> > > + .upper_bound = 1, .lower_bound = 1, .result = 0,
> > > + },
> > > + // 2 - Upper Bound
> > > + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> > > + .observed = {.tv_sec = 2, .tv_nsec = 0},
> > > + .upper_bound = 2, .lower_bound = 1, .result = 1,
> > > + },
> > > + // 3 - Lower Bound
> > > + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> > > + .observed = {.tv_sec = 0, .tv_nsec = 0},
> > > + .upper_bound = 1, .lower_bound = 0, .result = 1,
> > > + },
> > > + // 4 - Out of range by nanosecs
> > > + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> > > + .observed = {.tv_sec = 1, .tv_nsec = 500},
> > > + .upper_bound = 1, .lower_bound = 1, .result = 0,
> > > + },
> > > + // 5 - In range by nanosecs
> > > + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> > > + .observed = {.tv_sec = 1, .tv_nsec = 50000},
> > > + .upper_bound = 1.3, .lower_bound = 1, .result = 1,
> > > + },
> > > + // 6 - Big nanosecs
> > > + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> > > + .observed = {.tv_sec = 0, .tv_nsec = 4000000},
> > > + .upper_bound = 1, .lower_bound = .001, .result = 1,
> > > + },
> > > + // 7 - In range Negative values
> > > + {.expected = {.tv_sec = -1, .tv_nsec = 0},
> > > + .observed = {.tv_sec = -1, .tv_nsec = 0},
> > > + .upper_bound = 1, .lower_bound = 1, .result = 1,
> > > + },
> > > + // 8 - Out of range Negative values
> > > + {.expected = {.tv_sec = -1, .tv_nsec = 0},
> > > + .observed = {.tv_sec = -1, .tv_nsec = 0},
> > > + .upper_bound = -1, .lower_bound = -1, .result = 0,
> > > + },
> > > + // 9 - Negative values with negative nanosecs
> > > + {.expected = {.tv_sec = -1, .tv_nsec = 0},
> > > + .observed = {.tv_sec = -1, .tv_nsec = -2000},
> > > + .upper_bound = 1, .lower_bound = 1, .result = 0,
> > > + },
> > > + // 10 - Strict bounds
> > > + {.expected = {.tv_sec = -1, .tv_nsec = 0},
> > > + .observed = {.tv_sec = -1, .tv_nsec = -20000},
> > > + .upper_bound = 1.00002, .lower_bound = 1.0000191, .result = 1,
> > > + },
> > > + // 11 - Strict bounds with loose upper bound
> > > + {.expected = {.tv_sec = 1, .tv_nsec = 20000},
> > > + .observed = {.tv_sec = 1, .tv_nsec = 30000},
> > > + .upper_bound = 1.0000100000, .lower_bound = 1.0000099998, .result = 1,
> > > + },
> > > + // 12 - Strict bounds with loose lower bound
> > > + {.expected = {.tv_sec = 1, .tv_nsec = 20000},
> > > + .observed = {.tv_sec = 1, .tv_nsec = 30000},
> > > + .upper_bound = 1.0000099999, .lower_bound = 1.00000999979, .result = 1,
> > > + },
> > > + // 13 - Strict bounds highest precision
> > > + {.expected = {.tv_sec = 1, .tv_nsec = 20000},
> > > + .observed = {.tv_sec = 1, .tv_nsec = 30000},
> > > + .upper_bound = 1.00000999980001, .lower_bound = 1.00000999979999, .result = 1,
> > > + },
> > > + /* Maximum/Minimum long values */
> > > + // 14
> > > + {.expected = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ - 1},
> > > + .observed = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ - 2},
> > > + .upper_bound = 1, .lower_bound = .9, .result = 1,
> > > + },
> > > + // 15 - support_timespec_ns overflow
> > > + {.expected = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> > > + .observed = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> > > + .upper_bound = 1, .lower_bound = 1, .result = 1,
> > > + },
> > > + // 16 - support_timespec_ns overflow + underflow
> > > + {.expected = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> > > + .observed = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> > > + .upper_bound = 1, .lower_bound = 1, .result = 0,
> > > + },
> > > + // 17 - support_timespec_ns underflow
> > > + {.expected = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> > > + .observed = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> > > + .upper_bound = 1, .lower_bound = 1, .result = 1,
> > > + },
> > > + // 18 - support_timespec_ns underflow + overflow
> > > + {.expected = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> > > + .observed = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> > > + .upper_bound = 1, .lower_bound = 1, .result = 0,
> > > + },
> > > + // 19 - Biggest division
> > > + {.expected = {.tv_sec = LONG_MAX / TIMESPEC_HZ , .tv_nsec = TIMESPEC_HZ - 1},
> > > + .observed = {.tv_sec = 0, .tv_nsec = 1},
> > > + .upper_bound = 1, .lower_bound = 1.0842021724855044e-19, .result = 1,
> > > + },
> > > + // 20 - Lowest division
> > > + {.expected = {.tv_sec = 0, .tv_nsec = 1},
> > > + .observed = {.tv_sec = LONG_MAX / TIMESPEC_HZ , .tv_nsec = TIMESPEC_HZ - 1},
> > > + .upper_bound = LONG_MAX, .lower_bound = 1, .result = 1,
> > > + },
> > > +};
> > > +
> > > +static int
> > > +do_test (void)
> > > +{
> > > + int i = 0;
> > > + int ntests = sizeof (ns_cases) / sizeof (ns_cases[0]);
> > > +
> > > + printf("Testing support_timespec_ns\n");
> > > + for (i = 0; i < ntests; i++)
> > > + {
> > > + TEST_COMPARE (support_timespec_ns (ns_cases[i].time),
> > > + ns_cases[i].time_ns);
> > > + }
> > > +
> > > + ntests = sizeof (norm_cases) / sizeof (norm_cases[0]);
> > > + struct timespec result;
> > > + printf("Testing support_timespec_normalize\n");
> > > + for (i = 0; i < ntests; i++)
> > > + {
> > > + result = support_timespec_normalize (norm_cases[i].time);
> > > + TEST_COMPARE (norm_cases[i].norm.tv_sec, result.tv_sec);
> > > + TEST_COMPARE (norm_cases[i].norm.tv_nsec, result.tv_nsec);
> > > + }
> > > +
> > > + ntests = sizeof (check_cases) / sizeof (check_cases[0]);
> > > + printf("Testing support_timespec_check_in_range\n");
> > > + for (i = 0; i < ntests; i++)
> > > + {
> > > + /* Its hard to find which test failed with just the TEST_COMPARE report.
> > > + So here we print every running testcase as well. */
> > > + printf("Test case %d\n", i);
> > > + TEST_COMPARE (support_timespec_check_in_range
> > > + (check_cases[i].expected, check_cases[i].observed,
> > > + check_cases[i].lower_bound,
> > > + check_cases[i].upper_bound), check_cases[i].result);
> > > + }
> > > + return 0;
> > > +}
> > > +
> > > +#include <support/test-driver.c>
> > > diff --git a/time/tst-cpuclock1.c b/time/tst-cpuclock1.c
> > > index 0120906f23..1ac611a92b 100644
> > > --- a/time/tst-cpuclock1.c
> > > +++ b/time/tst-cpuclock1.c
> > > @@ -26,6 +26,7 @@
> > > #include <signal.h>
> > > #include <stdint.h>
> > > #include <sys/wait.h>
> > > +#include <support/timespec.h>
> > >
> > > /* This function is intended to rack up both user and system time. */
> > > static void
> > > @@ -155,16 +156,12 @@ do_test (void)
> > > printf ("live PID %d after sleep => %ju.%.9ju\n",
> > > child, (uintmax_t) after.tv_sec, (uintmax_t) after.tv_nsec);
> > >
> > > - struct timespec diff = { .tv_sec = after.tv_sec - before.tv_sec,
> > > - .tv_nsec = after.tv_nsec - before.tv_nsec };
> > > - if (diff.tv_nsec < 0)
> > > - {
> > > - --diff.tv_sec;
> > > - diff.tv_nsec += 1000000000;
> > > - }
> > > - if (diff.tv_sec != 0
> > > - || diff.tv_nsec > 600000000
> > > - || diff.tv_nsec < 100000000)
> > > + /* The bound values are empirically defined by testing this code over high cpu
> > > + usage and different nice values. Of all the values we keep the 90th
> > > + percentile of values and use those values for our testing allowed range. */
> > > + struct timespec diff = timespec_sub (support_timespec_normalize (after),
> > > + support_timespec_normalize (before));
> > > + if (!support_timespec_check_in_range (sleeptime, diff, .9, 1.1))
> > > {
> > > printf ("before - after %ju.%.9ju outside reasonable range\n",
> > > (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> > > @@ -194,19 +191,16 @@ do_test (void)
> > > }
> > > else
> > > {
> > > - struct timespec d = { .tv_sec = afterns.tv_sec - after.tv_sec,
> > > - .tv_nsec = afterns.tv_nsec - after.tv_nsec };
> > > - if (d.tv_nsec < 0)
> > > - {
> > > - --d.tv_sec;
> > > - d.tv_nsec += 1000000000;
> > > - }
> > > - if (d.tv_sec > 0
> > > - || d.tv_nsec < sleeptime.tv_nsec
> > > - || d.tv_nsec > sleeptime.tv_nsec * 2)
> > > + /* The bound values are empirically defined by testing this code over
> > > + high cpu usage and different nice values. Of all the values we keep
> > > + the 90th percentile of values and use those values for our testing
> > > + allowed range. */
> > > + diff = timespec_sub (support_timespec_normalize (afterns),
> > > + support_timespec_normalize (after));
> > > + if (!support_timespec_check_in_range (sleeptime, diff, .9, 1.2))
> > > {
> > > printf ("nanosleep time %ju.%.9ju outside reasonable range\n",
> > > - (uintmax_t) d.tv_sec, (uintmax_t) d.tv_nsec);
> > > + (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> > > result = 1;
> > > }
> > > }
> > > @@ -240,15 +234,13 @@ do_test (void)
> > > /* Should be close to 0.6. */
> > > printf ("dead PID %d => %ju.%.9ju\n",
> > > child, (uintmax_t) dead.tv_sec, (uintmax_t) dead.tv_nsec);
> > > -
> > > - diff.tv_sec = dead.tv_sec - after.tv_sec;
> > > - diff.tv_nsec = dead.tv_nsec - after.tv_nsec;
> > > - if (diff.tv_nsec < 0)
> > > - {
> > > - --diff.tv_sec;
> > > - diff.tv_nsec += 1000000000;
> > > - }
> > > - if (diff.tv_sec != 0 || diff.tv_nsec > 200000000)
> > > + /* The bound values are empirically defined by testing this code over high cpu
> > > + usage and different nice values. Of all the values we keep the 90th
> > > + percentile of values and use those values for our testing allowed range. */
> > > + diff = timespec_sub (support_timespec_normalize (dead),
> > > + support_timespec_normalize (after));
> > > + sleeptime.tv_nsec = 100000000;
> > > + if (!support_timespec_check_in_range (sleeptime, diff, .9, 1.2))
> > > {
> > > printf ("dead - after %ju.%.9ju outside reasonable range\n",
> > > (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> > > --
> > > 2.20.1
> > >
^ permalink raw reply [flat|nested] 44+ messages in thread
* Re: [PATCH v9] Fix time/tst-cpuclock1 intermitent failures
2020-04-21 17:44 ` [PATCH v9] " Lucas A. M. Magalhaes via Libc-alpha
2020-05-11 17:41 ` Lucas A. M. Magalhaes via Libc-alpha
@ 2020-06-08 16:52 ` Carlos O'Donell via Libc-alpha
2020-06-12 15:28 ` [PATCH v10] " Lucas A. M. Magalhaes via Libc-alpha
2 siblings, 0 replies; 44+ messages in thread
From: Carlos O'Donell via Libc-alpha @ 2020-06-08 16:52 UTC (permalink / raw)
To: Lucas A. M. Magalhaes, libc-alpha
On 4/21/20 1:44 PM, Lucas A. M. Magalhaes wrote:
> This test fails intermittently in systems with heavy load as
> CLOCK_PROCESS_CPUTIME_ID is subject to scheduler pressure. Thus the
> test boundaries were relaxed to keep it from failing on such systems.
>
> A refactor of the spent time checking was made with some support
> functions. With the advantage to representing time jitter in percent
> of the target.
>
> The values used by the test boundaries are all empirical.
>
> ---
>
> Hi Carlos,
> I also got skeptical about my dataset so I genegerated another one.
> That .4 boundry was indeed too low. Also, the support/tst-timespec was
> not actually running any tests because of a lazy bug, sorry about that.
> Thanks for taking the time for reviewing this.
*Almost* done.
Please review suggestions and comment changes.
Post v10 and I'll ACK that.
> changes on V9:
> Add new testcases
> Fix support/tst-timespec do_run
> Add comments
> Change boundaries
>
> changes on V8:
> Add support_timespec_ns
> Add more tests
>
> This list of changes where getting to long.
> ---
> support/Makefile | 1 +
> support/timespec.c | 64 +++++++++
> support/timespec.h | 8 ++
> support/tst-timespec.c | 320 +++++++++++++++++++++++++++++++++++++++++
> time/tst-cpuclock1.c | 52 +++----
> 5 files changed, 415 insertions(+), 30 deletions(-)
> create mode 100644 support/tst-timespec.c
>
> diff --git a/support/Makefile b/support/Makefile
> index 6e38b87ebe..cacaac96a5 100644
> --- a/support/Makefile
> +++ b/support/Makefile
> @@ -233,6 +233,7 @@ tests = \
> tst-test_compare \
> tst-test_compare_blob \
> tst-test_compare_string \
> + tst-timespec \
OK. Add new test.
> tst-xreadlink \
> tst-xsigstack \
>
> diff --git a/support/timespec.c b/support/timespec.c
> index ea6b947546..103beafdc4 100644
> --- a/support/timespec.c
> +++ b/support/timespec.c
> @@ -19,6 +19,8 @@
> #include <support/timespec.h>
> #include <stdio.h>
> #include <stdint.h>
> +#include <assert.h>
> +#include <intprops.h>
OK.
>
> void
> test_timespec_before_impl (const char *file, int line,
> @@ -57,3 +59,65 @@ test_timespec_equal_or_after_impl (const char *file, int line,
> (intmax_t) diff.tv_sec, (intmax_t) diff.tv_nsec);
> }
> }
> +
> +/* Convert TIME to nanoseconds stored in shrinked in a long.
Suggest:
Convert TIME to nanoseconds stored in a long.
> + Returns long maximum or minimum if the conversion overflows
> + or underflows, respectively. */
OK. Good we document that we clamp at max or min with no wrapping.
> +long
> +support_timespec_ns (struct timespec time)
> +{
> + long time_ns;
> + if (INT_MULTIPLY_WRAPV(time.tv_sec, TIMESPEC_HZ, &time_ns))
> + {
> + return (time.tv_sec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long);
OK. Negative multiply that wraps clamps to minimum negative long, while positive
multiple that wraps clamps to maximum positive long.
> + }
> + if (INT_ADD_WRAPV(time_ns, time.tv_nsec, &time_ns))
> + {
> + return (time.tv_nsec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long);
OK. Likewise for addition.
> + }
> + return time_ns;
> +}
> +
> +/* Returns t normalized timespec with .tv_nsec < TIMESPEC_HZ
Suggest:
Returns time normalized timespec with .tv_nsec < TIMESPEC_HZ
> + and the whole seconds added to .tv_sec. If an overflow or
> + underflow occurs the values are clamped to its maximum or
> + minimum respectively. */
> +struct timespec
> +support_timespec_normalize (struct timespec time)
> +{
> + struct timespec norm;
> + if (INT_ADD_WRAPV (time.tv_sec, (time.tv_nsec / TIMESPEC_HZ), &norm.tv_sec))
> + {
> + norm.tv_sec = (time.tv_nsec < 0) ? TYPE_MINIMUM (time_t): TYPE_MAXIMUM (time_t);
OK. Yes, seconds clamp at min or max for the type. Which is normalized.
> + norm.tv_nsec = (time.tv_nsec < 0) ? -1 * (TIMESPEC_HZ - 1) : TIMESPEC_HZ - 1;
OK. Yes, nanoseconds clamp at min or max of (TIMESPEC_HZ - 1).
> + return norm;
> + }
> + norm.tv_nsec = time.tv_nsec % TIMESPEC_HZ;
OK.
> + return norm;
> +}
> +
> +/* Returns TRUE if the observed time is within the given percentage
> + bounds of the expected time, and FALSE otherwise.
> + For example the call
> +
> + support_timespec_check_in_range(expected, observed, .5, 1.2);
Suggest:
support_timespec_check_in_range(expected, observed, 0.5, 1.2);
> +
> + will check if
> +
> + .5 <= observed/expected <= 1.2
Suggest:
50% of expected <= observed <= 120% of expected
> +
> + In other words it will check if observed time is within 50% to
> + 120% of the expected time. */
> +int
> +support_timespec_check_in_range (struct timespec expected, struct timespec observed,
> + double lower_bound, double upper_bound)
> +{
> + assert (upper_bound >= lower_bound);
> + long expected_norm, observed_norm;
> + expected_norm = support_timespec_ns (expected);
> + /* Don't divide by zero */
> + assert(expected_norm != 0);
> + observed_norm = support_timespec_ns (observed);
> + double ratio = (double)observed_norm / expected_norm;
> + return (lower_bound <= ratio && ratio <= upper_bound);
OK.
> +}
> diff --git a/support/timespec.h b/support/timespec.h
> index c5852dfe75..fd5466745d 100644
> --- a/support/timespec.h
> +++ b/support/timespec.h
> @@ -48,6 +48,14 @@ void test_timespec_equal_or_after_impl (const char *file, int line,
> const struct timespec left,
> const struct timespec right);
>
> +long support_timespec_ns (struct timespec time);
> +
> +struct timespec support_timespec_normalize (struct timespec time);
> +
> +int support_timespec_check_in_range (struct timespec expected, struct timespec observed,
> + double lower_bound, double upper_bound);
OK.
> +
> +
> /* Check that the timespec on the left represents a time before the
> time on the right. */
> #define TEST_TIMESPEC_BEFORE(left, right) \
> diff --git a/support/tst-timespec.c b/support/tst-timespec.c
> new file mode 100644
> index 0000000000..b421b219fd
> --- /dev/null
> +++ b/support/tst-timespec.c
> @@ -0,0 +1,320 @@
> +/* Test for support_timespec_check_in_range function.
> + Copyright (C) 2020 Free Software Foundation, Inc.
> + This file is part of the GNU C Library.
> +
> + The GNU C Library is free software; you can redistribute it and/or
> + modify it under the terms of the GNU Lesser General Public
> + License as published by the Free Software Foundation; either
> + version 2.1 of the License, or (at your option) any later version.
> +
> + The GNU C Library is distributed in the hope that it will be useful,
> + but WITHOUT ANY WARRANTY; without even the implied warranty of
> + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> + Lesser General Public License for more details.
> +
> + You should have received a copy of the GNU Lesser General Public
> + License along with the GNU C Library; if not, see
> + <https://www.gnu.org/licenses/>. */
> +
> +#include <support/timespec.h>
> +#include <support/check.h>
> +#include <limits.h>
> +
> +#define TIMESPEC_HZ 1000000000
> +
> +struct timespec_ns_test_case
> +{
> + struct timespec time;
> + long time_ns;
> +};
> +
> +struct timespec_norm_test_case
> +{
> + struct timespec time;
> + struct timespec norm;
> +};
> +
> +struct timespec_test_case
> +{
> + struct timespec expected;
> + struct timespec observed;
> + double upper_bound;
> + double lower_bound;
> + int result;
> +};
> +
> +/* Test cases for timespec_ns */
> +struct timespec_ns_test_case ns_cases[] = {
> + {.time = {.tv_sec = 0, .tv_nsec = 0},
> + .time_ns = 0,
> + },
> + {.time = {.tv_sec = 0, .tv_nsec = 1},
> + .time_ns = 1,
> + },
> + {.time = {.tv_sec = 1, .tv_nsec = 0},
> + .time_ns = TIMESPEC_HZ,
> + },
> + {.time = {.tv_sec = 1, .tv_nsec = 1},
> + .time_ns = TIMESPEC_HZ + 1,
> + },
> + {.time = {.tv_sec = 0, .tv_nsec = -1},
> + .time_ns = -1,
> + },
> + {.time = {.tv_sec = -1, .tv_nsec = 0},
> + .time_ns = -TIMESPEC_HZ,
> + },
> + {.time = {.tv_sec = -1, .tv_nsec = -1},
> + .time_ns = -TIMESPEC_HZ - 1,
> + },
> + {.time = {.tv_sec = 1, .tv_nsec = -1},
> + .time_ns = TIMESPEC_HZ - 1,
> + },
> + {.time = {.tv_sec = -1, .tv_nsec = 1},
> + .time_ns = -TIMESPEC_HZ + 1,
> + },
> + // Overflow bondary by 2
Change all of these comments to use GNU-style e.g. /* Foo. */
> + {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ, .tv_nsec = LONG_MAX%TIMESPEC_HZ - 1},
> + .time_ns = LONG_MAX - 1,
> + },
> + // Overflow bondary
> + {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ, .tv_nsec = LONG_MAX%TIMESPEC_HZ},
> + .time_ns = LONG_MAX,
> + },
> + // Underflow bondary by 1
> + {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ, .tv_nsec = LONG_MIN%TIMESPEC_HZ + 1},
> + .time_ns = LONG_MIN + 1,
> + },
> + // Underflow bondary
> + {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ, .tv_nsec = LONG_MIN%TIMESPEC_HZ},
> + .time_ns = LONG_MIN,
> + },
> + // Multiplication overflow
> + {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ + 1, .tv_nsec = 1},
> + .time_ns = LONG_MAX,
> + },
> + // Multiplication underflow
> + {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ - 1, .tv_nsec = -1},
> + .time_ns = LONG_MIN,
> + },
> + // Sum overflows
> + {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ, .tv_nsec = LONG_MAX%TIMESPEC_HZ + 1},
> + .time_ns = LONG_MAX,
> + },
> + // Sum underflow
> + {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ, .tv_nsec = LONG_MIN%TIMESPEC_HZ - 1},
> + .time_ns = LONG_MIN,
> + }
> +};
> +
> +/* Test cases for timespec_norm */
> +struct timespec_norm_test_case norm_cases[] = {
> + // Positive cases
> + {.time = {.tv_sec = 0, .tv_nsec = 0},
> + .norm = {.tv_sec = 0, .tv_nsec = 0}
> + },
> + {.time = {.tv_sec = 1, .tv_nsec = 0},
> + .norm = {.tv_sec = 1, .tv_nsec = 0}
> + },
> + {.time = {.tv_sec = 0, .tv_nsec = 1},
> + .norm = {.tv_sec = 0, .tv_nsec = 1}
> + },
> + {.time = {.tv_sec = 0, .tv_nsec = TIMESPEC_HZ},
> + .norm = {.tv_sec = 1, .tv_nsec = 0}
> + },
> + {.time = {.tv_sec = 0, .tv_nsec = TIMESPEC_HZ + 1},
> + .norm = {.tv_sec = 1, .tv_nsec = 1}
> + },
> + {.time = {.tv_sec = 1, .tv_nsec = TIMESPEC_HZ},
> + .norm = {.tv_sec = 2, .tv_nsec = 0}
> + },
> + {.time = {.tv_sec = 1, .tv_nsec = TIMESPEC_HZ + 1},
> + .norm = {.tv_sec = 2, .tv_nsec = 1}
> + },
> + // Negative cases
> + {.time = {.tv_sec = 0, .tv_nsec = -TIMESPEC_HZ},
> + .norm = {.tv_sec = -1, .tv_nsec = 0}
> + },
> + {.time = {.tv_sec = 0, .tv_nsec = -TIMESPEC_HZ - 1},
> + .norm = {.tv_sec = -1, .tv_nsec = -1}
> + },
> + {.time = {.tv_sec = -1, .tv_nsec = -TIMESPEC_HZ},
> + .norm = {.tv_sec = -2, .tv_nsec = 0}
> + },
> + {.time = {.tv_sec = -1, .tv_nsec = -TIMESPEC_HZ - 1},
> + .norm = {.tv_sec = -2, .tv_nsec = -1}
> + },
> + // Overflow bondary by 2
> + {.time = {.tv_sec = LONG_MAX - 2, .tv_nsec = TIMESPEC_HZ + 1},
> + .norm = {.tv_sec = LONG_MAX - 1, 1},
> + },
> + // Overflow bondary by 1
> + {.time = {.tv_sec = LONG_MAX - 1, .tv_nsec = TIMESPEC_HZ + 1},
> + .norm = {.tv_sec = LONG_MAX, .tv_nsec = 1},
> + },
> + // Underflow bondary by 2
> + {.time = {.tv_sec = LONG_MIN + 2, .tv_nsec = -TIMESPEC_HZ - 1},
> + .norm = {.tv_sec = LONG_MIN + 1, -1},
> + },
> + // Underflow bondary by 1
> + {.time = {.tv_sec = LONG_MIN + 1, .tv_nsec = -TIMESPEC_HZ - 1},
> + .norm = {.tv_sec = LONG_MIN, .tv_nsec = -1},
> + },
> + // SUM overflow
> + {.time = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> + .norm = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ - 1},
> + },
> + // SUM underflow
> + {.time = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> + .norm = {.tv_sec = LONG_MIN, .tv_nsec = -1 * (TIMESPEC_HZ - 1)},
> + }
> +};
> +
> +/* Test cases for timespec_check_in_range */
> +struct timespec_test_case check_cases[] = {
> + // 0 - In range
> + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> + .observed = {.tv_sec = 1, .tv_nsec = 0},
> + .upper_bound = 1, .lower_bound = 1, .result = 1,
> + },
> + // 1 - Out of range
> + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> + .observed = {.tv_sec = 2, .tv_nsec = 0},
> + .upper_bound = 1, .lower_bound = 1, .result = 0,
> + },
> + // 2 - Upper Bound
> + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> + .observed = {.tv_sec = 2, .tv_nsec = 0},
> + .upper_bound = 2, .lower_bound = 1, .result = 1,
> + },
> + // 3 - Lower Bound
> + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> + .observed = {.tv_sec = 0, .tv_nsec = 0},
> + .upper_bound = 1, .lower_bound = 0, .result = 1,
> + },
> + // 4 - Out of range by nanosecs
> + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> + .observed = {.tv_sec = 1, .tv_nsec = 500},
> + .upper_bound = 1, .lower_bound = 1, .result = 0,
> + },
> + // 5 - In range by nanosecs
> + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> + .observed = {.tv_sec = 1, .tv_nsec = 50000},
> + .upper_bound = 1.3, .lower_bound = 1, .result = 1,
> + },
> + // 6 - Big nanosecs
> + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> + .observed = {.tv_sec = 0, .tv_nsec = 4000000},
> + .upper_bound = 1, .lower_bound = .001, .result = 1,
> + },
> + // 7 - In range Negative values
> + {.expected = {.tv_sec = -1, .tv_nsec = 0},
> + .observed = {.tv_sec = -1, .tv_nsec = 0},
> + .upper_bound = 1, .lower_bound = 1, .result = 1,
> + },
> + // 8 - Out of range Negative values
> + {.expected = {.tv_sec = -1, .tv_nsec = 0},
> + .observed = {.tv_sec = -1, .tv_nsec = 0},
> + .upper_bound = -1, .lower_bound = -1, .result = 0,
> + },
> + // 9 - Negative values with negative nanosecs
> + {.expected = {.tv_sec = -1, .tv_nsec = 0},
> + .observed = {.tv_sec = -1, .tv_nsec = -2000},
> + .upper_bound = 1, .lower_bound = 1, .result = 0,
> + },
> + // 10 - Strict bounds
> + {.expected = {.tv_sec = -1, .tv_nsec = 0},
> + .observed = {.tv_sec = -1, .tv_nsec = -20000},
> + .upper_bound = 1.00002, .lower_bound = 1.0000191, .result = 1,
> + },
> + // 11 - Strict bounds with loose upper bound
> + {.expected = {.tv_sec = 1, .tv_nsec = 20000},
> + .observed = {.tv_sec = 1, .tv_nsec = 30000},
> + .upper_bound = 1.0000100000, .lower_bound = 1.0000099998, .result = 1,
> + },
> + // 12 - Strict bounds with loose lower bound
> + {.expected = {.tv_sec = 1, .tv_nsec = 20000},
> + .observed = {.tv_sec = 1, .tv_nsec = 30000},
> + .upper_bound = 1.0000099999, .lower_bound = 1.00000999979, .result = 1,
> + },
> + // 13 - Strict bounds highest precision
> + {.expected = {.tv_sec = 1, .tv_nsec = 20000},
> + .observed = {.tv_sec = 1, .tv_nsec = 30000},
> + .upper_bound = 1.00000999980001, .lower_bound = 1.00000999979999, .result = 1,
> + },
> + /* Maximum/Minimum long values */
> + // 14
> + {.expected = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ - 1},
> + .observed = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ - 2},
> + .upper_bound = 1, .lower_bound = .9, .result = 1,
> + },
> + // 15 - support_timespec_ns overflow
> + {.expected = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> + .observed = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> + .upper_bound = 1, .lower_bound = 1, .result = 1,
> + },
> + // 16 - support_timespec_ns overflow + underflow
> + {.expected = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> + .observed = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> + .upper_bound = 1, .lower_bound = 1, .result = 0,
> + },
> + // 17 - support_timespec_ns underflow
> + {.expected = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> + .observed = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> + .upper_bound = 1, .lower_bound = 1, .result = 1,
> + },
> + // 18 - support_timespec_ns underflow + overflow
> + {.expected = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> + .observed = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> + .upper_bound = 1, .lower_bound = 1, .result = 0,
> + },
> + // 19 - Biggest division
> + {.expected = {.tv_sec = LONG_MAX / TIMESPEC_HZ , .tv_nsec = TIMESPEC_HZ - 1},
> + .observed = {.tv_sec = 0, .tv_nsec = 1},
> + .upper_bound = 1, .lower_bound = 1.0842021724855044e-19, .result = 1,
> + },
> + // 20 - Lowest division
> + {.expected = {.tv_sec = 0, .tv_nsec = 1},
> + .observed = {.tv_sec = LONG_MAX / TIMESPEC_HZ , .tv_nsec = TIMESPEC_HZ - 1},
> + .upper_bound = LONG_MAX, .lower_bound = 1, .result = 1,
> + },
> +};
> +
> +static int
> +do_test (void)
> +{
> + int i = 0;
> + int ntests = sizeof (ns_cases) / sizeof (ns_cases[0]);
> +
> + printf("Testing support_timespec_ns\n");
> + for (i = 0; i < ntests; i++)
> + {
> + TEST_COMPARE (support_timespec_ns (ns_cases[i].time),
> + ns_cases[i].time_ns);
> + }
> +
> + ntests = sizeof (norm_cases) / sizeof (norm_cases[0]);
> + struct timespec result;
> + printf("Testing support_timespec_normalize\n");
> + for (i = 0; i < ntests; i++)
> + {
> + result = support_timespec_normalize (norm_cases[i].time);
> + TEST_COMPARE (norm_cases[i].norm.tv_sec, result.tv_sec);
> + TEST_COMPARE (norm_cases[i].norm.tv_nsec, result.tv_nsec);
> + }
> +
> + ntests = sizeof (check_cases) / sizeof (check_cases[0]);
> + printf("Testing support_timespec_check_in_range\n");
> + for (i = 0; i < ntests; i++)
> + {
> + /* Its hard to find which test failed with just the TEST_COMPARE report.
> + So here we print every running testcase as well. */
> + printf("Test case %d\n", i);
> + TEST_COMPARE (support_timespec_check_in_range
> + (check_cases[i].expected, check_cases[i].observed,
> + check_cases[i].lower_bound,
> + check_cases[i].upper_bound), check_cases[i].result);
> + }
> + return 0;
> +}
> +
> +#include <support/test-driver.c>
OK.
> diff --git a/time/tst-cpuclock1.c b/time/tst-cpuclock1.c
> index 0120906f23..1ac611a92b 100644
> --- a/time/tst-cpuclock1.c
> +++ b/time/tst-cpuclock1.c
> @@ -26,6 +26,7 @@
> #include <signal.h>
> #include <stdint.h>
> #include <sys/wait.h>
> +#include <support/timespec.h>
>
> /* This function is intended to rack up both user and system time. */
> static void
> @@ -155,16 +156,12 @@ do_test (void)
> printf ("live PID %d after sleep => %ju.%.9ju\n",
> child, (uintmax_t) after.tv_sec, (uintmax_t) after.tv_nsec);
>
> - struct timespec diff = { .tv_sec = after.tv_sec - before.tv_sec,
> - .tv_nsec = after.tv_nsec - before.tv_nsec };
> - if (diff.tv_nsec < 0)
> - {
> - --diff.tv_sec;
> - diff.tv_nsec += 1000000000;
> - }
> - if (diff.tv_sec != 0
> - || diff.tv_nsec > 600000000
> - || diff.tv_nsec < 100000000)
> + /* The bound values are empirically defined by testing this code over high cpu
> + usage and different nice values. Of all the values we keep the 90th
> + percentile of values and use those values for our testing allowed range. */
> + struct timespec diff = timespec_sub (support_timespec_normalize (after),
> + support_timespec_normalize (before));
> + if (!support_timespec_check_in_range (sleeptime, diff, .9, 1.1))
OK.
> {
> printf ("before - after %ju.%.9ju outside reasonable range\n",
> (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> @@ -194,19 +191,16 @@ do_test (void)
> }
> else
> {
> - struct timespec d = { .tv_sec = afterns.tv_sec - after.tv_sec,
> - .tv_nsec = afterns.tv_nsec - after.tv_nsec };
> - if (d.tv_nsec < 0)
> - {
> - --d.tv_sec;
> - d.tv_nsec += 1000000000;
> - }
> - if (d.tv_sec > 0
> - || d.tv_nsec < sleeptime.tv_nsec
> - || d.tv_nsec > sleeptime.tv_nsec * 2)
> + /* The bound values are empirically defined by testing this code over
> + high cpu usage and different nice values. Of all the values we keep
> + the 90th percentile of values and use those values for our testing
> + allowed range. */
> + diff = timespec_sub (support_timespec_normalize (afterns),
> + support_timespec_normalize (after));
> + if (!support_timespec_check_in_range (sleeptime, diff, .9, 1.2))
OK.
> {
> printf ("nanosleep time %ju.%.9ju outside reasonable range\n",
> - (uintmax_t) d.tv_sec, (uintmax_t) d.tv_nsec);
> + (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> result = 1;
> }
> }
> @@ -240,15 +234,13 @@ do_test (void)
> /* Should be close to 0.6. */
> printf ("dead PID %d => %ju.%.9ju\n",
> child, (uintmax_t) dead.tv_sec, (uintmax_t) dead.tv_nsec);
> -
> - diff.tv_sec = dead.tv_sec - after.tv_sec;
> - diff.tv_nsec = dead.tv_nsec - after.tv_nsec;
> - if (diff.tv_nsec < 0)
> - {
> - --diff.tv_sec;
> - diff.tv_nsec += 1000000000;
> - }
> - if (diff.tv_sec != 0 || diff.tv_nsec > 200000000)
> + /* The bound values are empirically defined by testing this code over high cpu
> + usage and different nice values. Of all the values we keep the 90th
> + percentile of values and use those values for our testing allowed range. */
> + diff = timespec_sub (support_timespec_normalize (dead),
> + support_timespec_normalize (after));
> + sleeptime.tv_nsec = 100000000;
> + if (!support_timespec_check_in_range (sleeptime, diff, .9, 1.2))
OK.
> {
> printf ("dead - after %ju.%.9ju outside reasonable range\n",
> (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
>
--
Cheers,
Carlos.
^ permalink raw reply [flat|nested] 44+ messages in thread* [PATCH v10] Fix time/tst-cpuclock1 intermitent failures
2020-04-21 17:44 ` [PATCH v9] " Lucas A. M. Magalhaes via Libc-alpha
2020-05-11 17:41 ` Lucas A. M. Magalhaes via Libc-alpha
2020-06-08 16:52 ` Carlos O'Donell via Libc-alpha
@ 2020-06-12 15:28 ` Lucas A. M. Magalhaes via Libc-alpha
2020-06-25 17:26 ` Lucas A. M. Magalhaes via Libc-alpha
2020-07-07 20:12 ` Carlos O'Donell via Libc-alpha
2 siblings, 2 replies; 44+ messages in thread
From: Lucas A. M. Magalhaes via Libc-alpha @ 2020-06-12 15:28 UTC (permalink / raw)
To: libc-alpha
This test fails intermittently in systems with heavy load as
CLOCK_PROCESS_CPUTIME_ID is subject to scheduler pressure. Thus the
test boundaries were relaxed to keep it from failing on such systems.
A refactor of the spent time checking was made with some support
functions. With the advantage to representing time jitter in percent
of the target.
The values used by the test boundaries are all empirical.
---
changes on V10:
Change comments
changes on V9:
Add new testcases
Fix support/tst-timespec do_run
Add comments
Change boundaries
changes on V8:
Add support_timespec_ns
Add more tests
This list of changes where getting to long.
---
support/Makefile | 1 +
support/timespec.c | 64 +++++++++
support/timespec.h | 8 ++
support/tst-timespec.c | 320 +++++++++++++++++++++++++++++++++++++++++
time/tst-cpuclock1.c | 52 +++----
5 files changed, 415 insertions(+), 30 deletions(-)
create mode 100644 support/tst-timespec.c
diff --git a/support/Makefile b/support/Makefile
index 51484310cd..914242d866 100644
--- a/support/Makefile
+++ b/support/Makefile
@@ -236,6 +236,7 @@ tests = \
tst-test_compare \
tst-test_compare_blob \
tst-test_compare_string \
+ tst-timespec \
tst-xreadlink \
tst-xsigstack \
diff --git a/support/timespec.c b/support/timespec.c
index ea6b947546..9f5449e49e 100644
--- a/support/timespec.c
+++ b/support/timespec.c
@@ -19,6 +19,8 @@
#include <support/timespec.h>
#include <stdio.h>
#include <stdint.h>
+#include <assert.h>
+#include <intprops.h>
void
test_timespec_before_impl (const char *file, int line,
@@ -57,3 +59,65 @@ test_timespec_equal_or_after_impl (const char *file, int line,
(intmax_t) diff.tv_sec, (intmax_t) diff.tv_nsec);
}
}
+
+/* Convert TIME to nanoseconds stored in a long.
+ Returns long maximum or minimum if the conversion overflows
+ or underflows, respectively. */
+long
+support_timespec_ns (struct timespec time)
+{
+ long time_ns;
+ if (INT_MULTIPLY_WRAPV(time.tv_sec, TIMESPEC_HZ, &time_ns))
+ {
+ return (time.tv_sec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long);
+ }
+ if (INT_ADD_WRAPV(time_ns, time.tv_nsec, &time_ns))
+ {
+ return (time.tv_nsec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long);
+ }
+ return time_ns;
+}
+
+/* Returns time normalized timespec with .tv_nsec < TIMESPEC_HZ
+ and the whole seconds added to .tv_sec. If an overflow or
+ underflow occurs the values are clamped to its maximum or
+ minimum respectively. */
+struct timespec
+support_timespec_normalize (struct timespec time)
+{
+ struct timespec norm;
+ if (INT_ADD_WRAPV (time.tv_sec, (time.tv_nsec / TIMESPEC_HZ), &norm.tv_sec))
+ {
+ norm.tv_sec = (time.tv_nsec < 0) ? TYPE_MINIMUM (time_t): TYPE_MAXIMUM (time_t);
+ norm.tv_nsec = (time.tv_nsec < 0) ? -1 * (TIMESPEC_HZ - 1) : TIMESPEC_HZ - 1;
+ return norm;
+ }
+ norm.tv_nsec = time.tv_nsec % TIMESPEC_HZ;
+ return norm;
+}
+
+/* Returns TRUE if the observed time is within the given percentage
+ bounds of the expected time, and FALSE otherwise.
+ For example the call
+
+ support_timespec_check_in_range(expected, observed, 0.5, 1.2);
+
+ will check if
+
+ 0.5 of expected <= observed <= 1.2 of expected
+
+ In other words it will check if observed time is within 50% to
+ 120% of the expected time. */
+int
+support_timespec_check_in_range (struct timespec expected, struct timespec observed,
+ double lower_bound, double upper_bound)
+{
+ assert (upper_bound >= lower_bound);
+ long expected_norm, observed_norm;
+ expected_norm = support_timespec_ns (expected);
+ /* Don't divide by zero */
+ assert(expected_norm != 0);
+ observed_norm = support_timespec_ns (observed);
+ double ratio = (double)observed_norm / expected_norm;
+ return (lower_bound <= ratio && ratio <= upper_bound);
+}
diff --git a/support/timespec.h b/support/timespec.h
index c5852dfe75..fd5466745d 100644
--- a/support/timespec.h
+++ b/support/timespec.h
@@ -48,6 +48,14 @@ void test_timespec_equal_or_after_impl (const char *file, int line,
const struct timespec left,
const struct timespec right);
+long support_timespec_ns (struct timespec time);
+
+struct timespec support_timespec_normalize (struct timespec time);
+
+int support_timespec_check_in_range (struct timespec expected, struct timespec observed,
+ double lower_bound, double upper_bound);
+
+
/* Check that the timespec on the left represents a time before the
time on the right. */
#define TEST_TIMESPEC_BEFORE(left, right) \
diff --git a/support/tst-timespec.c b/support/tst-timespec.c
new file mode 100644
index 0000000000..71423555a9
--- /dev/null
+++ b/support/tst-timespec.c
@@ -0,0 +1,320 @@
+/* Test for support_timespec_check_in_range function.
+ Copyright (C) 2020 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, see
+ <https://www.gnu.org/licenses/>. */
+
+#include <support/timespec.h>
+#include <support/check.h>
+#include <limits.h>
+
+#define TIMESPEC_HZ 1000000000
+
+struct timespec_ns_test_case
+{
+ struct timespec time;
+ long time_ns;
+};
+
+struct timespec_norm_test_case
+{
+ struct timespec time;
+ struct timespec norm;
+};
+
+struct timespec_test_case
+{
+ struct timespec expected;
+ struct timespec observed;
+ double upper_bound;
+ double lower_bound;
+ int result;
+};
+
+/* Test cases for timespec_ns */
+struct timespec_ns_test_case ns_cases[] = {
+ {.time = {.tv_sec = 0, .tv_nsec = 0},
+ .time_ns = 0,
+ },
+ {.time = {.tv_sec = 0, .tv_nsec = 1},
+ .time_ns = 1,
+ },
+ {.time = {.tv_sec = 1, .tv_nsec = 0},
+ .time_ns = TIMESPEC_HZ,
+ },
+ {.time = {.tv_sec = 1, .tv_nsec = 1},
+ .time_ns = TIMESPEC_HZ + 1,
+ },
+ {.time = {.tv_sec = 0, .tv_nsec = -1},
+ .time_ns = -1,
+ },
+ {.time = {.tv_sec = -1, .tv_nsec = 0},
+ .time_ns = -TIMESPEC_HZ,
+ },
+ {.time = {.tv_sec = -1, .tv_nsec = -1},
+ .time_ns = -TIMESPEC_HZ - 1,
+ },
+ {.time = {.tv_sec = 1, .tv_nsec = -1},
+ .time_ns = TIMESPEC_HZ - 1,
+ },
+ {.time = {.tv_sec = -1, .tv_nsec = 1},
+ .time_ns = -TIMESPEC_HZ + 1,
+ },
+ /* Overflow bondary by 2 */
+ {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ, .tv_nsec = LONG_MAX%TIMESPEC_HZ - 1},
+ .time_ns = LONG_MAX - 1,
+ },
+ /* Overflow bondary */
+ {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ, .tv_nsec = LONG_MAX%TIMESPEC_HZ},
+ .time_ns = LONG_MAX,
+ },
+ /* Underflow bondary by 1 */
+ {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ, .tv_nsec = LONG_MIN%TIMESPEC_HZ + 1},
+ .time_ns = LONG_MIN + 1,
+ },
+ /* Underflow bondary */
+ {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ, .tv_nsec = LONG_MIN%TIMESPEC_HZ},
+ .time_ns = LONG_MIN,
+ },
+ /* Multiplication overflow */
+ {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ + 1, .tv_nsec = 1},
+ .time_ns = LONG_MAX,
+ },
+ /* Multiplication underflow */
+ {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ - 1, .tv_nsec = -1},
+ .time_ns = LONG_MIN,
+ },
+ /* Sum overflows */
+ {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ, .tv_nsec = LONG_MAX%TIMESPEC_HZ + 1},
+ .time_ns = LONG_MAX,
+ },
+ /* Sum underflow */
+ {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ, .tv_nsec = LONG_MIN%TIMESPEC_HZ - 1},
+ .time_ns = LONG_MIN,
+ }
+};
+
+/* Test cases for timespec_norm */
+struct timespec_norm_test_case norm_cases[] = {
+ /* Positive cases */
+ {.time = {.tv_sec = 0, .tv_nsec = 0},
+ .norm = {.tv_sec = 0, .tv_nsec = 0}
+ },
+ {.time = {.tv_sec = 1, .tv_nsec = 0},
+ .norm = {.tv_sec = 1, .tv_nsec = 0}
+ },
+ {.time = {.tv_sec = 0, .tv_nsec = 1},
+ .norm = {.tv_sec = 0, .tv_nsec = 1}
+ },
+ {.time = {.tv_sec = 0, .tv_nsec = TIMESPEC_HZ},
+ .norm = {.tv_sec = 1, .tv_nsec = 0}
+ },
+ {.time = {.tv_sec = 0, .tv_nsec = TIMESPEC_HZ + 1},
+ .norm = {.tv_sec = 1, .tv_nsec = 1}
+ },
+ {.time = {.tv_sec = 1, .tv_nsec = TIMESPEC_HZ},
+ .norm = {.tv_sec = 2, .tv_nsec = 0}
+ },
+ {.time = {.tv_sec = 1, .tv_nsec = TIMESPEC_HZ + 1},
+ .norm = {.tv_sec = 2, .tv_nsec = 1}
+ },
+ /* Negative cases */
+ {.time = {.tv_sec = 0, .tv_nsec = -TIMESPEC_HZ},
+ .norm = {.tv_sec = -1, .tv_nsec = 0}
+ },
+ {.time = {.tv_sec = 0, .tv_nsec = -TIMESPEC_HZ - 1},
+ .norm = {.tv_sec = -1, .tv_nsec = -1}
+ },
+ {.time = {.tv_sec = -1, .tv_nsec = -TIMESPEC_HZ},
+ .norm = {.tv_sec = -2, .tv_nsec = 0}
+ },
+ {.time = {.tv_sec = -1, .tv_nsec = -TIMESPEC_HZ - 1},
+ .norm = {.tv_sec = -2, .tv_nsec = -1}
+ },
+ /* Overflow bondary by 2 */
+ {.time = {.tv_sec = LONG_MAX - 2, .tv_nsec = TIMESPEC_HZ + 1},
+ .norm = {.tv_sec = LONG_MAX - 1, 1},
+ },
+ /* Overflow bondary by 1 */
+ {.time = {.tv_sec = LONG_MAX - 1, .tv_nsec = TIMESPEC_HZ + 1},
+ .norm = {.tv_sec = LONG_MAX, .tv_nsec = 1},
+ },
+ /* Underflow bondary by 2 */
+ {.time = {.tv_sec = LONG_MIN + 2, .tv_nsec = -TIMESPEC_HZ - 1},
+ .norm = {.tv_sec = LONG_MIN + 1, -1},
+ },
+ /* Underflow bondary by 1 */
+ {.time = {.tv_sec = LONG_MIN + 1, .tv_nsec = -TIMESPEC_HZ - 1},
+ .norm = {.tv_sec = LONG_MIN, .tv_nsec = -1},
+ },
+ /* SUM overflow */
+ {.time = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
+ .norm = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ - 1},
+ },
+ /* SUM underflow */
+ {.time = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
+ .norm = {.tv_sec = LONG_MIN, .tv_nsec = -1 * (TIMESPEC_HZ - 1)},
+ }
+};
+
+/* Test cases for timespec_check_in_range */
+struct timespec_test_case check_cases[] = {
+ /* 0 - In range */
+ {.expected = {.tv_sec = 1, .tv_nsec = 0},
+ .observed = {.tv_sec = 1, .tv_nsec = 0},
+ .upper_bound = 1, .lower_bound = 1, .result = 1,
+ },
+ /* 1 - Out of range */
+ {.expected = {.tv_sec = 1, .tv_nsec = 0},
+ .observed = {.tv_sec = 2, .tv_nsec = 0},
+ .upper_bound = 1, .lower_bound = 1, .result = 0,
+ },
+ /* 2 - Upper Bound */
+ {.expected = {.tv_sec = 1, .tv_nsec = 0},
+ .observed = {.tv_sec = 2, .tv_nsec = 0},
+ .upper_bound = 2, .lower_bound = 1, .result = 1,
+ },
+ /* 3 - Lower Bound */
+ {.expected = {.tv_sec = 1, .tv_nsec = 0},
+ .observed = {.tv_sec = 0, .tv_nsec = 0},
+ .upper_bound = 1, .lower_bound = 0, .result = 1,
+ },
+ /* 4 - Out of range by nanosecs */
+ {.expected = {.tv_sec = 1, .tv_nsec = 0},
+ .observed = {.tv_sec = 1, .tv_nsec = 500},
+ .upper_bound = 1, .lower_bound = 1, .result = 0,
+ },
+ /* 5 - In range by nanosecs */
+ {.expected = {.tv_sec = 1, .tv_nsec = 0},
+ .observed = {.tv_sec = 1, .tv_nsec = 50000},
+ .upper_bound = 1.3, .lower_bound = 1, .result = 1,
+ },
+ /* 6 - Big nanosecs */
+ {.expected = {.tv_sec = 1, .tv_nsec = 0},
+ .observed = {.tv_sec = 0, .tv_nsec = 4000000},
+ .upper_bound = 1, .lower_bound = .001, .result = 1,
+ },
+ /* 7 - In range Negative values */
+ {.expected = {.tv_sec = -1, .tv_nsec = 0},
+ .observed = {.tv_sec = -1, .tv_nsec = 0},
+ .upper_bound = 1, .lower_bound = 1, .result = 1,
+ },
+ /* 8 - Out of range Negative values */
+ {.expected = {.tv_sec = -1, .tv_nsec = 0},
+ .observed = {.tv_sec = -1, .tv_nsec = 0},
+ .upper_bound = -1, .lower_bound = -1, .result = 0,
+ },
+ /* 9 - Negative values with negative nanosecs */
+ {.expected = {.tv_sec = -1, .tv_nsec = 0},
+ .observed = {.tv_sec = -1, .tv_nsec = -2000},
+ .upper_bound = 1, .lower_bound = 1, .result = 0,
+ },
+ /* 10 - Strict bounds */
+ {.expected = {.tv_sec = -1, .tv_nsec = 0},
+ .observed = {.tv_sec = -1, .tv_nsec = -20000},
+ .upper_bound = 1.00002, .lower_bound = 1.0000191, .result = 1,
+ },
+ /* 11 - Strict bounds with loose upper bound */
+ {.expected = {.tv_sec = 1, .tv_nsec = 20000},
+ .observed = {.tv_sec = 1, .tv_nsec = 30000},
+ .upper_bound = 1.0000100000, .lower_bound = 1.0000099998, .result = 1,
+ },
+ /* 12 - Strict bounds with loose lower bound */
+ {.expected = {.tv_sec = 1, .tv_nsec = 20000},
+ .observed = {.tv_sec = 1, .tv_nsec = 30000},
+ .upper_bound = 1.0000099999, .lower_bound = 1.00000999979, .result = 1,
+ },
+ /* 13 - Strict bounds highest precision */
+ {.expected = {.tv_sec = 1, .tv_nsec = 20000},
+ .observed = {.tv_sec = 1, .tv_nsec = 30000},
+ .upper_bound = 1.00000999980001, .lower_bound = 1.00000999979999, .result = 1,
+ },
+ /* Maximum/Minimum long values */
+ /* 14 */
+ {.expected = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ - 1},
+ .observed = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ - 2},
+ .upper_bound = 1, .lower_bound = .9, .result = 1,
+ },
+ /* 15 - support_timespec_ns overflow */
+ {.expected = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
+ .observed = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
+ .upper_bound = 1, .lower_bound = 1, .result = 1,
+ },
+ /* 16 - support_timespec_ns overflow + underflow */
+ {.expected = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
+ .observed = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
+ .upper_bound = 1, .lower_bound = 1, .result = 0,
+ },
+ /* 17 - support_timespec_ns underflow */
+ {.expected = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
+ .observed = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
+ .upper_bound = 1, .lower_bound = 1, .result = 1,
+ },
+ /* 18 - support_timespec_ns underflow + overflow */
+ {.expected = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
+ .observed = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
+ .upper_bound = 1, .lower_bound = 1, .result = 0,
+ },
+ /* 19 - Biggest division */
+ {.expected = {.tv_sec = LONG_MAX / TIMESPEC_HZ , .tv_nsec = TIMESPEC_HZ - 1},
+ .observed = {.tv_sec = 0, .tv_nsec = 1},
+ .upper_bound = 1, .lower_bound = 1.0842021724855044e-19, .result = 1,
+ },
+ /* 20 - Lowest division */
+ {.expected = {.tv_sec = 0, .tv_nsec = 1},
+ .observed = {.tv_sec = LONG_MAX / TIMESPEC_HZ , .tv_nsec = TIMESPEC_HZ - 1},
+ .upper_bound = LONG_MAX, .lower_bound = 1, .result = 1,
+ },
+};
+
+static int
+do_test (void)
+{
+ int i = 0;
+ int ntests = sizeof (ns_cases) / sizeof (ns_cases[0]);
+
+ printf("Testing support_timespec_ns\n");
+ for (i = 0; i < ntests; i++)
+ {
+ TEST_COMPARE (support_timespec_ns (ns_cases[i].time),
+ ns_cases[i].time_ns);
+ }
+
+ ntests = sizeof (norm_cases) / sizeof (norm_cases[0]);
+ struct timespec result;
+ printf("Testing support_timespec_normalize\n");
+ for (i = 0; i < ntests; i++)
+ {
+ result = support_timespec_normalize (norm_cases[i].time);
+ TEST_COMPARE (norm_cases[i].norm.tv_sec, result.tv_sec);
+ TEST_COMPARE (norm_cases[i].norm.tv_nsec, result.tv_nsec);
+ }
+
+ ntests = sizeof (check_cases) / sizeof (check_cases[0]);
+ printf("Testing support_timespec_check_in_range\n");
+ for (i = 0; i < ntests; i++)
+ {
+ /* Its hard to find which test failed with just the TEST_COMPARE report.
+ So here we print every running testcase as well. */
+ printf("Test case %d\n", i);
+ TEST_COMPARE (support_timespec_check_in_range
+ (check_cases[i].expected, check_cases[i].observed,
+ check_cases[i].lower_bound,
+ check_cases[i].upper_bound), check_cases[i].result);
+ }
+ return 0;
+}
+
+#include <support/test-driver.c>
diff --git a/time/tst-cpuclock1.c b/time/tst-cpuclock1.c
index 0120906f23..1ac611a92b 100644
--- a/time/tst-cpuclock1.c
+++ b/time/tst-cpuclock1.c
@@ -26,6 +26,7 @@
#include <signal.h>
#include <stdint.h>
#include <sys/wait.h>
+#include <support/timespec.h>
/* This function is intended to rack up both user and system time. */
static void
@@ -155,16 +156,12 @@ do_test (void)
printf ("live PID %d after sleep => %ju.%.9ju\n",
child, (uintmax_t) after.tv_sec, (uintmax_t) after.tv_nsec);
- struct timespec diff = { .tv_sec = after.tv_sec - before.tv_sec,
- .tv_nsec = after.tv_nsec - before.tv_nsec };
- if (diff.tv_nsec < 0)
- {
- --diff.tv_sec;
- diff.tv_nsec += 1000000000;
- }
- if (diff.tv_sec != 0
- || diff.tv_nsec > 600000000
- || diff.tv_nsec < 100000000)
+ /* The bound values are empirically defined by testing this code over high cpu
+ usage and different nice values. Of all the values we keep the 90th
+ percentile of values and use those values for our testing allowed range. */
+ struct timespec diff = timespec_sub (support_timespec_normalize (after),
+ support_timespec_normalize (before));
+ if (!support_timespec_check_in_range (sleeptime, diff, .9, 1.1))
{
printf ("before - after %ju.%.9ju outside reasonable range\n",
(uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
@@ -194,19 +191,16 @@ do_test (void)
}
else
{
- struct timespec d = { .tv_sec = afterns.tv_sec - after.tv_sec,
- .tv_nsec = afterns.tv_nsec - after.tv_nsec };
- if (d.tv_nsec < 0)
- {
- --d.tv_sec;
- d.tv_nsec += 1000000000;
- }
- if (d.tv_sec > 0
- || d.tv_nsec < sleeptime.tv_nsec
- || d.tv_nsec > sleeptime.tv_nsec * 2)
+ /* The bound values are empirically defined by testing this code over
+ high cpu usage and different nice values. Of all the values we keep
+ the 90th percentile of values and use those values for our testing
+ allowed range. */
+ diff = timespec_sub (support_timespec_normalize (afterns),
+ support_timespec_normalize (after));
+ if (!support_timespec_check_in_range (sleeptime, diff, .9, 1.2))
{
printf ("nanosleep time %ju.%.9ju outside reasonable range\n",
- (uintmax_t) d.tv_sec, (uintmax_t) d.tv_nsec);
+ (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
result = 1;
}
}
@@ -240,15 +234,13 @@ do_test (void)
/* Should be close to 0.6. */
printf ("dead PID %d => %ju.%.9ju\n",
child, (uintmax_t) dead.tv_sec, (uintmax_t) dead.tv_nsec);
-
- diff.tv_sec = dead.tv_sec - after.tv_sec;
- diff.tv_nsec = dead.tv_nsec - after.tv_nsec;
- if (diff.tv_nsec < 0)
- {
- --diff.tv_sec;
- diff.tv_nsec += 1000000000;
- }
- if (diff.tv_sec != 0 || diff.tv_nsec > 200000000)
+ /* The bound values are empirically defined by testing this code over high cpu
+ usage and different nice values. Of all the values we keep the 90th
+ percentile of values and use those values for our testing allowed range. */
+ diff = timespec_sub (support_timespec_normalize (dead),
+ support_timespec_normalize (after));
+ sleeptime.tv_nsec = 100000000;
+ if (!support_timespec_check_in_range (sleeptime, diff, .9, 1.2))
{
printf ("dead - after %ju.%.9ju outside reasonable range\n",
(uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
--
2.26.2
^ permalink raw reply related [flat|nested] 44+ messages in thread* Re: [PATCH v10] Fix time/tst-cpuclock1 intermitent failures
2020-06-12 15:28 ` [PATCH v10] " Lucas A. M. Magalhaes via Libc-alpha
@ 2020-06-25 17:26 ` Lucas A. M. Magalhaes via Libc-alpha
2020-07-06 14:15 ` Lucas A. M. Magalhaes via Libc-alpha
2020-07-07 20:12 ` Carlos O'Donell via Libc-alpha
1 sibling, 1 reply; 44+ messages in thread
From: Lucas A. M. Magalhaes via Libc-alpha @ 2020-06-25 17:26 UTC (permalink / raw)
To: libc-alpha
Ping
Quoting Lucas A. M. Magalhaes via Libc-alpha (2020-06-12 12:28:17)
> This test fails intermittently in systems with heavy load as
> CLOCK_PROCESS_CPUTIME_ID is subject to scheduler pressure. Thus the
> test boundaries were relaxed to keep it from failing on such systems.
>
> A refactor of the spent time checking was made with some support
> functions. With the advantage to representing time jitter in percent
> of the target.
>
> The values used by the test boundaries are all empirical.
>
> ---
>
> changes on V10:
> Change comments
>
> changes on V9:
> Add new testcases
> Fix support/tst-timespec do_run
> Add comments
> Change boundaries
>
> changes on V8:
> Add support_timespec_ns
> Add more tests
>
> This list of changes where getting to long.
> ---
> support/Makefile | 1 +
> support/timespec.c | 64 +++++++++
> support/timespec.h | 8 ++
> support/tst-timespec.c | 320 +++++++++++++++++++++++++++++++++++++++++
> time/tst-cpuclock1.c | 52 +++----
> 5 files changed, 415 insertions(+), 30 deletions(-)
> create mode 100644 support/tst-timespec.c
>
> diff --git a/support/Makefile b/support/Makefile
> index 51484310cd..914242d866 100644
> --- a/support/Makefile
> +++ b/support/Makefile
> @@ -236,6 +236,7 @@ tests = \
> tst-test_compare \
> tst-test_compare_blob \
> tst-test_compare_string \
> + tst-timespec \
> tst-xreadlink \
> tst-xsigstack \
>
> diff --git a/support/timespec.c b/support/timespec.c
> index ea6b947546..9f5449e49e 100644
> --- a/support/timespec.c
> +++ b/support/timespec.c
> @@ -19,6 +19,8 @@
> #include <support/timespec.h>
> #include <stdio.h>
> #include <stdint.h>
> +#include <assert.h>
> +#include <intprops.h>
>
> void
> test_timespec_before_impl (const char *file, int line,
> @@ -57,3 +59,65 @@ test_timespec_equal_or_after_impl (const char *file, int line,
> (intmax_t) diff.tv_sec, (intmax_t) diff.tv_nsec);
> }
> }
> +
> +/* Convert TIME to nanoseconds stored in a long.
> + Returns long maximum or minimum if the conversion overflows
> + or underflows, respectively. */
> +long
> +support_timespec_ns (struct timespec time)
> +{
> + long time_ns;
> + if (INT_MULTIPLY_WRAPV(time.tv_sec, TIMESPEC_HZ, &time_ns))
> + {
> + return (time.tv_sec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long);
> + }
> + if (INT_ADD_WRAPV(time_ns, time.tv_nsec, &time_ns))
> + {
> + return (time.tv_nsec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long);
> + }
> + return time_ns;
> +}
> +
> +/* Returns time normalized timespec with .tv_nsec < TIMESPEC_HZ
> + and the whole seconds added to .tv_sec. If an overflow or
> + underflow occurs the values are clamped to its maximum or
> + minimum respectively. */
> +struct timespec
> +support_timespec_normalize (struct timespec time)
> +{
> + struct timespec norm;
> + if (INT_ADD_WRAPV (time.tv_sec, (time.tv_nsec / TIMESPEC_HZ), &norm.tv_sec))
> + {
> + norm.tv_sec = (time.tv_nsec < 0) ? TYPE_MINIMUM (time_t): TYPE_MAXIMUM (time_t);
> + norm.tv_nsec = (time.tv_nsec < 0) ? -1 * (TIMESPEC_HZ - 1) : TIMESPEC_HZ - 1;
> + return norm;
> + }
> + norm.tv_nsec = time.tv_nsec % TIMESPEC_HZ;
> + return norm;
> +}
> +
> +/* Returns TRUE if the observed time is within the given percentage
> + bounds of the expected time, and FALSE otherwise.
> + For example the call
> +
> + support_timespec_check_in_range(expected, observed, 0.5, 1.2);
> +
> + will check if
> +
> + 0.5 of expected <= observed <= 1.2 of expected
> +
> + In other words it will check if observed time is within 50% to
> + 120% of the expected time. */
> +int
> +support_timespec_check_in_range (struct timespec expected, struct timespec observed,
> + double lower_bound, double upper_bound)
> +{
> + assert (upper_bound >= lower_bound);
> + long expected_norm, observed_norm;
> + expected_norm = support_timespec_ns (expected);
> + /* Don't divide by zero */
> + assert(expected_norm != 0);
> + observed_norm = support_timespec_ns (observed);
> + double ratio = (double)observed_norm / expected_norm;
> + return (lower_bound <= ratio && ratio <= upper_bound);
> +}
> diff --git a/support/timespec.h b/support/timespec.h
> index c5852dfe75..fd5466745d 100644
> --- a/support/timespec.h
> +++ b/support/timespec.h
> @@ -48,6 +48,14 @@ void test_timespec_equal_or_after_impl (const char *file, int line,
> const struct timespec left,
> const struct timespec right);
>
> +long support_timespec_ns (struct timespec time);
> +
> +struct timespec support_timespec_normalize (struct timespec time);
> +
> +int support_timespec_check_in_range (struct timespec expected, struct timespec observed,
> + double lower_bound, double upper_bound);
> +
> +
> /* Check that the timespec on the left represents a time before the
> time on the right. */
> #define TEST_TIMESPEC_BEFORE(left, right) \
> diff --git a/support/tst-timespec.c b/support/tst-timespec.c
> new file mode 100644
> index 0000000000..71423555a9
> --- /dev/null
> +++ b/support/tst-timespec.c
> @@ -0,0 +1,320 @@
> +/* Test for support_timespec_check_in_range function.
> + Copyright (C) 2020 Free Software Foundation, Inc.
> + This file is part of the GNU C Library.
> +
> + The GNU C Library is free software; you can redistribute it and/or
> + modify it under the terms of the GNU Lesser General Public
> + License as published by the Free Software Foundation; either
> + version 2.1 of the License, or (at your option) any later version.
> +
> + The GNU C Library is distributed in the hope that it will be useful,
> + but WITHOUT ANY WARRANTY; without even the implied warranty of
> + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> + Lesser General Public License for more details.
> +
> + You should have received a copy of the GNU Lesser General Public
> + License along with the GNU C Library; if not, see
> + <https://www.gnu.org/licenses/>. */
> +
> +#include <support/timespec.h>
> +#include <support/check.h>
> +#include <limits.h>
> +
> +#define TIMESPEC_HZ 1000000000
> +
> +struct timespec_ns_test_case
> +{
> + struct timespec time;
> + long time_ns;
> +};
> +
> +struct timespec_norm_test_case
> +{
> + struct timespec time;
> + struct timespec norm;
> +};
> +
> +struct timespec_test_case
> +{
> + struct timespec expected;
> + struct timespec observed;
> + double upper_bound;
> + double lower_bound;
> + int result;
> +};
> +
> +/* Test cases for timespec_ns */
> +struct timespec_ns_test_case ns_cases[] = {
> + {.time = {.tv_sec = 0, .tv_nsec = 0},
> + .time_ns = 0,
> + },
> + {.time = {.tv_sec = 0, .tv_nsec = 1},
> + .time_ns = 1,
> + },
> + {.time = {.tv_sec = 1, .tv_nsec = 0},
> + .time_ns = TIMESPEC_HZ,
> + },
> + {.time = {.tv_sec = 1, .tv_nsec = 1},
> + .time_ns = TIMESPEC_HZ + 1,
> + },
> + {.time = {.tv_sec = 0, .tv_nsec = -1},
> + .time_ns = -1,
> + },
> + {.time = {.tv_sec = -1, .tv_nsec = 0},
> + .time_ns = -TIMESPEC_HZ,
> + },
> + {.time = {.tv_sec = -1, .tv_nsec = -1},
> + .time_ns = -TIMESPEC_HZ - 1,
> + },
> + {.time = {.tv_sec = 1, .tv_nsec = -1},
> + .time_ns = TIMESPEC_HZ - 1,
> + },
> + {.time = {.tv_sec = -1, .tv_nsec = 1},
> + .time_ns = -TIMESPEC_HZ + 1,
> + },
> + /* Overflow bondary by 2 */
> + {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ, .tv_nsec = LONG_MAX%TIMESPEC_HZ - 1},
> + .time_ns = LONG_MAX - 1,
> + },
> + /* Overflow bondary */
> + {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ, .tv_nsec = LONG_MAX%TIMESPEC_HZ},
> + .time_ns = LONG_MAX,
> + },
> + /* Underflow bondary by 1 */
> + {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ, .tv_nsec = LONG_MIN%TIMESPEC_HZ + 1},
> + .time_ns = LONG_MIN + 1,
> + },
> + /* Underflow bondary */
> + {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ, .tv_nsec = LONG_MIN%TIMESPEC_HZ},
> + .time_ns = LONG_MIN,
> + },
> + /* Multiplication overflow */
> + {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ + 1, .tv_nsec = 1},
> + .time_ns = LONG_MAX,
> + },
> + /* Multiplication underflow */
> + {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ - 1, .tv_nsec = -1},
> + .time_ns = LONG_MIN,
> + },
> + /* Sum overflows */
> + {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ, .tv_nsec = LONG_MAX%TIMESPEC_HZ + 1},
> + .time_ns = LONG_MAX,
> + },
> + /* Sum underflow */
> + {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ, .tv_nsec = LONG_MIN%TIMESPEC_HZ - 1},
> + .time_ns = LONG_MIN,
> + }
> +};
> +
> +/* Test cases for timespec_norm */
> +struct timespec_norm_test_case norm_cases[] = {
> + /* Positive cases */
> + {.time = {.tv_sec = 0, .tv_nsec = 0},
> + .norm = {.tv_sec = 0, .tv_nsec = 0}
> + },
> + {.time = {.tv_sec = 1, .tv_nsec = 0},
> + .norm = {.tv_sec = 1, .tv_nsec = 0}
> + },
> + {.time = {.tv_sec = 0, .tv_nsec = 1},
> + .norm = {.tv_sec = 0, .tv_nsec = 1}
> + },
> + {.time = {.tv_sec = 0, .tv_nsec = TIMESPEC_HZ},
> + .norm = {.tv_sec = 1, .tv_nsec = 0}
> + },
> + {.time = {.tv_sec = 0, .tv_nsec = TIMESPEC_HZ + 1},
> + .norm = {.tv_sec = 1, .tv_nsec = 1}
> + },
> + {.time = {.tv_sec = 1, .tv_nsec = TIMESPEC_HZ},
> + .norm = {.tv_sec = 2, .tv_nsec = 0}
> + },
> + {.time = {.tv_sec = 1, .tv_nsec = TIMESPEC_HZ + 1},
> + .norm = {.tv_sec = 2, .tv_nsec = 1}
> + },
> + /* Negative cases */
> + {.time = {.tv_sec = 0, .tv_nsec = -TIMESPEC_HZ},
> + .norm = {.tv_sec = -1, .tv_nsec = 0}
> + },
> + {.time = {.tv_sec = 0, .tv_nsec = -TIMESPEC_HZ - 1},
> + .norm = {.tv_sec = -1, .tv_nsec = -1}
> + },
> + {.time = {.tv_sec = -1, .tv_nsec = -TIMESPEC_HZ},
> + .norm = {.tv_sec = -2, .tv_nsec = 0}
> + },
> + {.time = {.tv_sec = -1, .tv_nsec = -TIMESPEC_HZ - 1},
> + .norm = {.tv_sec = -2, .tv_nsec = -1}
> + },
> + /* Overflow bondary by 2 */
> + {.time = {.tv_sec = LONG_MAX - 2, .tv_nsec = TIMESPEC_HZ + 1},
> + .norm = {.tv_sec = LONG_MAX - 1, 1},
> + },
> + /* Overflow bondary by 1 */
> + {.time = {.tv_sec = LONG_MAX - 1, .tv_nsec = TIMESPEC_HZ + 1},
> + .norm = {.tv_sec = LONG_MAX, .tv_nsec = 1},
> + },
> + /* Underflow bondary by 2 */
> + {.time = {.tv_sec = LONG_MIN + 2, .tv_nsec = -TIMESPEC_HZ - 1},
> + .norm = {.tv_sec = LONG_MIN + 1, -1},
> + },
> + /* Underflow bondary by 1 */
> + {.time = {.tv_sec = LONG_MIN + 1, .tv_nsec = -TIMESPEC_HZ - 1},
> + .norm = {.tv_sec = LONG_MIN, .tv_nsec = -1},
> + },
> + /* SUM overflow */
> + {.time = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> + .norm = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ - 1},
> + },
> + /* SUM underflow */
> + {.time = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> + .norm = {.tv_sec = LONG_MIN, .tv_nsec = -1 * (TIMESPEC_HZ - 1)},
> + }
> +};
> +
> +/* Test cases for timespec_check_in_range */
> +struct timespec_test_case check_cases[] = {
> + /* 0 - In range */
> + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> + .observed = {.tv_sec = 1, .tv_nsec = 0},
> + .upper_bound = 1, .lower_bound = 1, .result = 1,
> + },
> + /* 1 - Out of range */
> + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> + .observed = {.tv_sec = 2, .tv_nsec = 0},
> + .upper_bound = 1, .lower_bound = 1, .result = 0,
> + },
> + /* 2 - Upper Bound */
> + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> + .observed = {.tv_sec = 2, .tv_nsec = 0},
> + .upper_bound = 2, .lower_bound = 1, .result = 1,
> + },
> + /* 3 - Lower Bound */
> + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> + .observed = {.tv_sec = 0, .tv_nsec = 0},
> + .upper_bound = 1, .lower_bound = 0, .result = 1,
> + },
> + /* 4 - Out of range by nanosecs */
> + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> + .observed = {.tv_sec = 1, .tv_nsec = 500},
> + .upper_bound = 1, .lower_bound = 1, .result = 0,
> + },
> + /* 5 - In range by nanosecs */
> + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> + .observed = {.tv_sec = 1, .tv_nsec = 50000},
> + .upper_bound = 1.3, .lower_bound = 1, .result = 1,
> + },
> + /* 6 - Big nanosecs */
> + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> + .observed = {.tv_sec = 0, .tv_nsec = 4000000},
> + .upper_bound = 1, .lower_bound = .001, .result = 1,
> + },
> + /* 7 - In range Negative values */
> + {.expected = {.tv_sec = -1, .tv_nsec = 0},
> + .observed = {.tv_sec = -1, .tv_nsec = 0},
> + .upper_bound = 1, .lower_bound = 1, .result = 1,
> + },
> + /* 8 - Out of range Negative values */
> + {.expected = {.tv_sec = -1, .tv_nsec = 0},
> + .observed = {.tv_sec = -1, .tv_nsec = 0},
> + .upper_bound = -1, .lower_bound = -1, .result = 0,
> + },
> + /* 9 - Negative values with negative nanosecs */
> + {.expected = {.tv_sec = -1, .tv_nsec = 0},
> + .observed = {.tv_sec = -1, .tv_nsec = -2000},
> + .upper_bound = 1, .lower_bound = 1, .result = 0,
> + },
> + /* 10 - Strict bounds */
> + {.expected = {.tv_sec = -1, .tv_nsec = 0},
> + .observed = {.tv_sec = -1, .tv_nsec = -20000},
> + .upper_bound = 1.00002, .lower_bound = 1.0000191, .result = 1,
> + },
> + /* 11 - Strict bounds with loose upper bound */
> + {.expected = {.tv_sec = 1, .tv_nsec = 20000},
> + .observed = {.tv_sec = 1, .tv_nsec = 30000},
> + .upper_bound = 1.0000100000, .lower_bound = 1.0000099998, .result = 1,
> + },
> + /* 12 - Strict bounds with loose lower bound */
> + {.expected = {.tv_sec = 1, .tv_nsec = 20000},
> + .observed = {.tv_sec = 1, .tv_nsec = 30000},
> + .upper_bound = 1.0000099999, .lower_bound = 1.00000999979, .result = 1,
> + },
> + /* 13 - Strict bounds highest precision */
> + {.expected = {.tv_sec = 1, .tv_nsec = 20000},
> + .observed = {.tv_sec = 1, .tv_nsec = 30000},
> + .upper_bound = 1.00000999980001, .lower_bound = 1.00000999979999, .result = 1,
> + },
> + /* Maximum/Minimum long values */
> + /* 14 */
> + {.expected = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ - 1},
> + .observed = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ - 2},
> + .upper_bound = 1, .lower_bound = .9, .result = 1,
> + },
> + /* 15 - support_timespec_ns overflow */
> + {.expected = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> + .observed = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> + .upper_bound = 1, .lower_bound = 1, .result = 1,
> + },
> + /* 16 - support_timespec_ns overflow + underflow */
> + {.expected = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> + .observed = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> + .upper_bound = 1, .lower_bound = 1, .result = 0,
> + },
> + /* 17 - support_timespec_ns underflow */
> + {.expected = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> + .observed = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> + .upper_bound = 1, .lower_bound = 1, .result = 1,
> + },
> + /* 18 - support_timespec_ns underflow + overflow */
> + {.expected = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> + .observed = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> + .upper_bound = 1, .lower_bound = 1, .result = 0,
> + },
> + /* 19 - Biggest division */
> + {.expected = {.tv_sec = LONG_MAX / TIMESPEC_HZ , .tv_nsec = TIMESPEC_HZ - 1},
> + .observed = {.tv_sec = 0, .tv_nsec = 1},
> + .upper_bound = 1, .lower_bound = 1.0842021724855044e-19, .result = 1,
> + },
> + /* 20 - Lowest division */
> + {.expected = {.tv_sec = 0, .tv_nsec = 1},
> + .observed = {.tv_sec = LONG_MAX / TIMESPEC_HZ , .tv_nsec = TIMESPEC_HZ - 1},
> + .upper_bound = LONG_MAX, .lower_bound = 1, .result = 1,
> + },
> +};
> +
> +static int
> +do_test (void)
> +{
> + int i = 0;
> + int ntests = sizeof (ns_cases) / sizeof (ns_cases[0]);
> +
> + printf("Testing support_timespec_ns\n");
> + for (i = 0; i < ntests; i++)
> + {
> + TEST_COMPARE (support_timespec_ns (ns_cases[i].time),
> + ns_cases[i].time_ns);
> + }
> +
> + ntests = sizeof (norm_cases) / sizeof (norm_cases[0]);
> + struct timespec result;
> + printf("Testing support_timespec_normalize\n");
> + for (i = 0; i < ntests; i++)
> + {
> + result = support_timespec_normalize (norm_cases[i].time);
> + TEST_COMPARE (norm_cases[i].norm.tv_sec, result.tv_sec);
> + TEST_COMPARE (norm_cases[i].norm.tv_nsec, result.tv_nsec);
> + }
> +
> + ntests = sizeof (check_cases) / sizeof (check_cases[0]);
> + printf("Testing support_timespec_check_in_range\n");
> + for (i = 0; i < ntests; i++)
> + {
> + /* Its hard to find which test failed with just the TEST_COMPARE report.
> + So here we print every running testcase as well. */
> + printf("Test case %d\n", i);
> + TEST_COMPARE (support_timespec_check_in_range
> + (check_cases[i].expected, check_cases[i].observed,
> + check_cases[i].lower_bound,
> + check_cases[i].upper_bound), check_cases[i].result);
> + }
> + return 0;
> +}
> +
> +#include <support/test-driver.c>
> diff --git a/time/tst-cpuclock1.c b/time/tst-cpuclock1.c
> index 0120906f23..1ac611a92b 100644
> --- a/time/tst-cpuclock1.c
> +++ b/time/tst-cpuclock1.c
> @@ -26,6 +26,7 @@
> #include <signal.h>
> #include <stdint.h>
> #include <sys/wait.h>
> +#include <support/timespec.h>
>
> /* This function is intended to rack up both user and system time. */
> static void
> @@ -155,16 +156,12 @@ do_test (void)
> printf ("live PID %d after sleep => %ju.%.9ju\n",
> child, (uintmax_t) after.tv_sec, (uintmax_t) after.tv_nsec);
>
> - struct timespec diff = { .tv_sec = after.tv_sec - before.tv_sec,
> - .tv_nsec = after.tv_nsec - before.tv_nsec };
> - if (diff.tv_nsec < 0)
> - {
> - --diff.tv_sec;
> - diff.tv_nsec += 1000000000;
> - }
> - if (diff.tv_sec != 0
> - || diff.tv_nsec > 600000000
> - || diff.tv_nsec < 100000000)
> + /* The bound values are empirically defined by testing this code over high cpu
> + usage and different nice values. Of all the values we keep the 90th
> + percentile of values and use those values for our testing allowed range. */
> + struct timespec diff = timespec_sub (support_timespec_normalize (after),
> + support_timespec_normalize (before));
> + if (!support_timespec_check_in_range (sleeptime, diff, .9, 1.1))
> {
> printf ("before - after %ju.%.9ju outside reasonable range\n",
> (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> @@ -194,19 +191,16 @@ do_test (void)
> }
> else
> {
> - struct timespec d = { .tv_sec = afterns.tv_sec - after.tv_sec,
> - .tv_nsec = afterns.tv_nsec - after.tv_nsec };
> - if (d.tv_nsec < 0)
> - {
> - --d.tv_sec;
> - d.tv_nsec += 1000000000;
> - }
> - if (d.tv_sec > 0
> - || d.tv_nsec < sleeptime.tv_nsec
> - || d.tv_nsec > sleeptime.tv_nsec * 2)
> + /* The bound values are empirically defined by testing this code over
> + high cpu usage and different nice values. Of all the values we keep
> + the 90th percentile of values and use those values for our testing
> + allowed range. */
> + diff = timespec_sub (support_timespec_normalize (afterns),
> + support_timespec_normalize (after));
> + if (!support_timespec_check_in_range (sleeptime, diff, .9, 1.2))
> {
> printf ("nanosleep time %ju.%.9ju outside reasonable range\n",
> - (uintmax_t) d.tv_sec, (uintmax_t) d.tv_nsec);
> + (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> result = 1;
> }
> }
> @@ -240,15 +234,13 @@ do_test (void)
> /* Should be close to 0.6. */
> printf ("dead PID %d => %ju.%.9ju\n",
> child, (uintmax_t) dead.tv_sec, (uintmax_t) dead.tv_nsec);
> -
> - diff.tv_sec = dead.tv_sec - after.tv_sec;
> - diff.tv_nsec = dead.tv_nsec - after.tv_nsec;
> - if (diff.tv_nsec < 0)
> - {
> - --diff.tv_sec;
> - diff.tv_nsec += 1000000000;
> - }
> - if (diff.tv_sec != 0 || diff.tv_nsec > 200000000)
> + /* The bound values are empirically defined by testing this code over high cpu
> + usage and different nice values. Of all the values we keep the 90th
> + percentile of values and use those values for our testing allowed range. */
> + diff = timespec_sub (support_timespec_normalize (dead),
> + support_timespec_normalize (after));
> + sleeptime.tv_nsec = 100000000;
> + if (!support_timespec_check_in_range (sleeptime, diff, .9, 1.2))
> {
> printf ("dead - after %ju.%.9ju outside reasonable range\n",
> (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> --
> 2.26.2
>
^ permalink raw reply [flat|nested] 44+ messages in thread* Re: [PATCH v10] Fix time/tst-cpuclock1 intermitent failures
2020-06-25 17:26 ` Lucas A. M. Magalhaes via Libc-alpha
@ 2020-07-06 14:15 ` Lucas A. M. Magalhaes via Libc-alpha
0 siblings, 0 replies; 44+ messages in thread
From: Lucas A. M. Magalhaes via Libc-alpha @ 2020-07-06 14:15 UTC (permalink / raw)
To: libc-alpha
Ping
Quoting Lucas A. M. Magalhaes (2020-06-25 14:26:20)
> Ping
>
> Quoting Lucas A. M. Magalhaes via Libc-alpha (2020-06-12 12:28:17)
> > This test fails intermittently in systems with heavy load as
> > CLOCK_PROCESS_CPUTIME_ID is subject to scheduler pressure. Thus the
> > test boundaries were relaxed to keep it from failing on such systems.
> >
> > A refactor of the spent time checking was made with some support
> > functions. With the advantage to representing time jitter in percent
> > of the target.
> >
> > The values used by the test boundaries are all empirical.
> >
> > ---
> >
> > changes on V10:
> > Change comments
> >
> > changes on V9:
> > Add new testcases
> > Fix support/tst-timespec do_run
> > Add comments
> > Change boundaries
> >
> > changes on V8:
> > Add support_timespec_ns
> > Add more tests
> >
> > This list of changes where getting to long.
> > ---
> > support/Makefile | 1 +
> > support/timespec.c | 64 +++++++++
> > support/timespec.h | 8 ++
> > support/tst-timespec.c | 320 +++++++++++++++++++++++++++++++++++++++++
> > time/tst-cpuclock1.c | 52 +++----
> > 5 files changed, 415 insertions(+), 30 deletions(-)
> > create mode 100644 support/tst-timespec.c
> >
> > diff --git a/support/Makefile b/support/Makefile
> > index 51484310cd..914242d866 100644
> > --- a/support/Makefile
> > +++ b/support/Makefile
> > @@ -236,6 +236,7 @@ tests = \
> > tst-test_compare \
> > tst-test_compare_blob \
> > tst-test_compare_string \
> > + tst-timespec \
> > tst-xreadlink \
> > tst-xsigstack \
> >
> > diff --git a/support/timespec.c b/support/timespec.c
> > index ea6b947546..9f5449e49e 100644
> > --- a/support/timespec.c
> > +++ b/support/timespec.c
> > @@ -19,6 +19,8 @@
> > #include <support/timespec.h>
> > #include <stdio.h>
> > #include <stdint.h>
> > +#include <assert.h>
> > +#include <intprops.h>
> >
> > void
> > test_timespec_before_impl (const char *file, int line,
> > @@ -57,3 +59,65 @@ test_timespec_equal_or_after_impl (const char *file, int line,
> > (intmax_t) diff.tv_sec, (intmax_t) diff.tv_nsec);
> > }
> > }
> > +
> > +/* Convert TIME to nanoseconds stored in a long.
> > + Returns long maximum or minimum if the conversion overflows
> > + or underflows, respectively. */
> > +long
> > +support_timespec_ns (struct timespec time)
> > +{
> > + long time_ns;
> > + if (INT_MULTIPLY_WRAPV(time.tv_sec, TIMESPEC_HZ, &time_ns))
> > + {
> > + return (time.tv_sec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long);
> > + }
> > + if (INT_ADD_WRAPV(time_ns, time.tv_nsec, &time_ns))
> > + {
> > + return (time.tv_nsec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long);
> > + }
> > + return time_ns;
> > +}
> > +
> > +/* Returns time normalized timespec with .tv_nsec < TIMESPEC_HZ
> > + and the whole seconds added to .tv_sec. If an overflow or
> > + underflow occurs the values are clamped to its maximum or
> > + minimum respectively. */
> > +struct timespec
> > +support_timespec_normalize (struct timespec time)
> > +{
> > + struct timespec norm;
> > + if (INT_ADD_WRAPV (time.tv_sec, (time.tv_nsec / TIMESPEC_HZ), &norm.tv_sec))
> > + {
> > + norm.tv_sec = (time.tv_nsec < 0) ? TYPE_MINIMUM (time_t): TYPE_MAXIMUM (time_t);
> > + norm.tv_nsec = (time.tv_nsec < 0) ? -1 * (TIMESPEC_HZ - 1) : TIMESPEC_HZ - 1;
> > + return norm;
> > + }
> > + norm.tv_nsec = time.tv_nsec % TIMESPEC_HZ;
> > + return norm;
> > +}
> > +
> > +/* Returns TRUE if the observed time is within the given percentage
> > + bounds of the expected time, and FALSE otherwise.
> > + For example the call
> > +
> > + support_timespec_check_in_range(expected, observed, 0.5, 1.2);
> > +
> > + will check if
> > +
> > + 0.5 of expected <= observed <= 1.2 of expected
> > +
> > + In other words it will check if observed time is within 50% to
> > + 120% of the expected time. */
> > +int
> > +support_timespec_check_in_range (struct timespec expected, struct timespec observed,
> > + double lower_bound, double upper_bound)
> > +{
> > + assert (upper_bound >= lower_bound);
> > + long expected_norm, observed_norm;
> > + expected_norm = support_timespec_ns (expected);
> > + /* Don't divide by zero */
> > + assert(expected_norm != 0);
> > + observed_norm = support_timespec_ns (observed);
> > + double ratio = (double)observed_norm / expected_norm;
> > + return (lower_bound <= ratio && ratio <= upper_bound);
> > +}
> > diff --git a/support/timespec.h b/support/timespec.h
> > index c5852dfe75..fd5466745d 100644
> > --- a/support/timespec.h
> > +++ b/support/timespec.h
> > @@ -48,6 +48,14 @@ void test_timespec_equal_or_after_impl (const char *file, int line,
> > const struct timespec left,
> > const struct timespec right);
> >
> > +long support_timespec_ns (struct timespec time);
> > +
> > +struct timespec support_timespec_normalize (struct timespec time);
> > +
> > +int support_timespec_check_in_range (struct timespec expected, struct timespec observed,
> > + double lower_bound, double upper_bound);
> > +
> > +
> > /* Check that the timespec on the left represents a time before the
> > time on the right. */
> > #define TEST_TIMESPEC_BEFORE(left, right) \
> > diff --git a/support/tst-timespec.c b/support/tst-timespec.c
> > new file mode 100644
> > index 0000000000..71423555a9
> > --- /dev/null
> > +++ b/support/tst-timespec.c
> > @@ -0,0 +1,320 @@
> > +/* Test for support_timespec_check_in_range function.
> > + Copyright (C) 2020 Free Software Foundation, Inc.
> > + This file is part of the GNU C Library.
> > +
> > + The GNU C Library is free software; you can redistribute it and/or
> > + modify it under the terms of the GNU Lesser General Public
> > + License as published by the Free Software Foundation; either
> > + version 2.1 of the License, or (at your option) any later version.
> > +
> > + The GNU C Library is distributed in the hope that it will be useful,
> > + but WITHOUT ANY WARRANTY; without even the implied warranty of
> > + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> > + Lesser General Public License for more details.
> > +
> > + You should have received a copy of the GNU Lesser General Public
> > + License along with the GNU C Library; if not, see
> > + <https://www.gnu.org/licenses/>. */
> > +
> > +#include <support/timespec.h>
> > +#include <support/check.h>
> > +#include <limits.h>
> > +
> > +#define TIMESPEC_HZ 1000000000
> > +
> > +struct timespec_ns_test_case
> > +{
> > + struct timespec time;
> > + long time_ns;
> > +};
> > +
> > +struct timespec_norm_test_case
> > +{
> > + struct timespec time;
> > + struct timespec norm;
> > +};
> > +
> > +struct timespec_test_case
> > +{
> > + struct timespec expected;
> > + struct timespec observed;
> > + double upper_bound;
> > + double lower_bound;
> > + int result;
> > +};
> > +
> > +/* Test cases for timespec_ns */
> > +struct timespec_ns_test_case ns_cases[] = {
> > + {.time = {.tv_sec = 0, .tv_nsec = 0},
> > + .time_ns = 0,
> > + },
> > + {.time = {.tv_sec = 0, .tv_nsec = 1},
> > + .time_ns = 1,
> > + },
> > + {.time = {.tv_sec = 1, .tv_nsec = 0},
> > + .time_ns = TIMESPEC_HZ,
> > + },
> > + {.time = {.tv_sec = 1, .tv_nsec = 1},
> > + .time_ns = TIMESPEC_HZ + 1,
> > + },
> > + {.time = {.tv_sec = 0, .tv_nsec = -1},
> > + .time_ns = -1,
> > + },
> > + {.time = {.tv_sec = -1, .tv_nsec = 0},
> > + .time_ns = -TIMESPEC_HZ,
> > + },
> > + {.time = {.tv_sec = -1, .tv_nsec = -1},
> > + .time_ns = -TIMESPEC_HZ - 1,
> > + },
> > + {.time = {.tv_sec = 1, .tv_nsec = -1},
> > + .time_ns = TIMESPEC_HZ - 1,
> > + },
> > + {.time = {.tv_sec = -1, .tv_nsec = 1},
> > + .time_ns = -TIMESPEC_HZ + 1,
> > + },
> > + /* Overflow bondary by 2 */
> > + {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ, .tv_nsec = LONG_MAX%TIMESPEC_HZ - 1},
> > + .time_ns = LONG_MAX - 1,
> > + },
> > + /* Overflow bondary */
> > + {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ, .tv_nsec = LONG_MAX%TIMESPEC_HZ},
> > + .time_ns = LONG_MAX,
> > + },
> > + /* Underflow bondary by 1 */
> > + {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ, .tv_nsec = LONG_MIN%TIMESPEC_HZ + 1},
> > + .time_ns = LONG_MIN + 1,
> > + },
> > + /* Underflow bondary */
> > + {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ, .tv_nsec = LONG_MIN%TIMESPEC_HZ},
> > + .time_ns = LONG_MIN,
> > + },
> > + /* Multiplication overflow */
> > + {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ + 1, .tv_nsec = 1},
> > + .time_ns = LONG_MAX,
> > + },
> > + /* Multiplication underflow */
> > + {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ - 1, .tv_nsec = -1},
> > + .time_ns = LONG_MIN,
> > + },
> > + /* Sum overflows */
> > + {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ, .tv_nsec = LONG_MAX%TIMESPEC_HZ + 1},
> > + .time_ns = LONG_MAX,
> > + },
> > + /* Sum underflow */
> > + {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ, .tv_nsec = LONG_MIN%TIMESPEC_HZ - 1},
> > + .time_ns = LONG_MIN,
> > + }
> > +};
> > +
> > +/* Test cases for timespec_norm */
> > +struct timespec_norm_test_case norm_cases[] = {
> > + /* Positive cases */
> > + {.time = {.tv_sec = 0, .tv_nsec = 0},
> > + .norm = {.tv_sec = 0, .tv_nsec = 0}
> > + },
> > + {.time = {.tv_sec = 1, .tv_nsec = 0},
> > + .norm = {.tv_sec = 1, .tv_nsec = 0}
> > + },
> > + {.time = {.tv_sec = 0, .tv_nsec = 1},
> > + .norm = {.tv_sec = 0, .tv_nsec = 1}
> > + },
> > + {.time = {.tv_sec = 0, .tv_nsec = TIMESPEC_HZ},
> > + .norm = {.tv_sec = 1, .tv_nsec = 0}
> > + },
> > + {.time = {.tv_sec = 0, .tv_nsec = TIMESPEC_HZ + 1},
> > + .norm = {.tv_sec = 1, .tv_nsec = 1}
> > + },
> > + {.time = {.tv_sec = 1, .tv_nsec = TIMESPEC_HZ},
> > + .norm = {.tv_sec = 2, .tv_nsec = 0}
> > + },
> > + {.time = {.tv_sec = 1, .tv_nsec = TIMESPEC_HZ + 1},
> > + .norm = {.tv_sec = 2, .tv_nsec = 1}
> > + },
> > + /* Negative cases */
> > + {.time = {.tv_sec = 0, .tv_nsec = -TIMESPEC_HZ},
> > + .norm = {.tv_sec = -1, .tv_nsec = 0}
> > + },
> > + {.time = {.tv_sec = 0, .tv_nsec = -TIMESPEC_HZ - 1},
> > + .norm = {.tv_sec = -1, .tv_nsec = -1}
> > + },
> > + {.time = {.tv_sec = -1, .tv_nsec = -TIMESPEC_HZ},
> > + .norm = {.tv_sec = -2, .tv_nsec = 0}
> > + },
> > + {.time = {.tv_sec = -1, .tv_nsec = -TIMESPEC_HZ - 1},
> > + .norm = {.tv_sec = -2, .tv_nsec = -1}
> > + },
> > + /* Overflow bondary by 2 */
> > + {.time = {.tv_sec = LONG_MAX - 2, .tv_nsec = TIMESPEC_HZ + 1},
> > + .norm = {.tv_sec = LONG_MAX - 1, 1},
> > + },
> > + /* Overflow bondary by 1 */
> > + {.time = {.tv_sec = LONG_MAX - 1, .tv_nsec = TIMESPEC_HZ + 1},
> > + .norm = {.tv_sec = LONG_MAX, .tv_nsec = 1},
> > + },
> > + /* Underflow bondary by 2 */
> > + {.time = {.tv_sec = LONG_MIN + 2, .tv_nsec = -TIMESPEC_HZ - 1},
> > + .norm = {.tv_sec = LONG_MIN + 1, -1},
> > + },
> > + /* Underflow bondary by 1 */
> > + {.time = {.tv_sec = LONG_MIN + 1, .tv_nsec = -TIMESPEC_HZ - 1},
> > + .norm = {.tv_sec = LONG_MIN, .tv_nsec = -1},
> > + },
> > + /* SUM overflow */
> > + {.time = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> > + .norm = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ - 1},
> > + },
> > + /* SUM underflow */
> > + {.time = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> > + .norm = {.tv_sec = LONG_MIN, .tv_nsec = -1 * (TIMESPEC_HZ - 1)},
> > + }
> > +};
> > +
> > +/* Test cases for timespec_check_in_range */
> > +struct timespec_test_case check_cases[] = {
> > + /* 0 - In range */
> > + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> > + .observed = {.tv_sec = 1, .tv_nsec = 0},
> > + .upper_bound = 1, .lower_bound = 1, .result = 1,
> > + },
> > + /* 1 - Out of range */
> > + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> > + .observed = {.tv_sec = 2, .tv_nsec = 0},
> > + .upper_bound = 1, .lower_bound = 1, .result = 0,
> > + },
> > + /* 2 - Upper Bound */
> > + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> > + .observed = {.tv_sec = 2, .tv_nsec = 0},
> > + .upper_bound = 2, .lower_bound = 1, .result = 1,
> > + },
> > + /* 3 - Lower Bound */
> > + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> > + .observed = {.tv_sec = 0, .tv_nsec = 0},
> > + .upper_bound = 1, .lower_bound = 0, .result = 1,
> > + },
> > + /* 4 - Out of range by nanosecs */
> > + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> > + .observed = {.tv_sec = 1, .tv_nsec = 500},
> > + .upper_bound = 1, .lower_bound = 1, .result = 0,
> > + },
> > + /* 5 - In range by nanosecs */
> > + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> > + .observed = {.tv_sec = 1, .tv_nsec = 50000},
> > + .upper_bound = 1.3, .lower_bound = 1, .result = 1,
> > + },
> > + /* 6 - Big nanosecs */
> > + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> > + .observed = {.tv_sec = 0, .tv_nsec = 4000000},
> > + .upper_bound = 1, .lower_bound = .001, .result = 1,
> > + },
> > + /* 7 - In range Negative values */
> > + {.expected = {.tv_sec = -1, .tv_nsec = 0},
> > + .observed = {.tv_sec = -1, .tv_nsec = 0},
> > + .upper_bound = 1, .lower_bound = 1, .result = 1,
> > + },
> > + /* 8 - Out of range Negative values */
> > + {.expected = {.tv_sec = -1, .tv_nsec = 0},
> > + .observed = {.tv_sec = -1, .tv_nsec = 0},
> > + .upper_bound = -1, .lower_bound = -1, .result = 0,
> > + },
> > + /* 9 - Negative values with negative nanosecs */
> > + {.expected = {.tv_sec = -1, .tv_nsec = 0},
> > + .observed = {.tv_sec = -1, .tv_nsec = -2000},
> > + .upper_bound = 1, .lower_bound = 1, .result = 0,
> > + },
> > + /* 10 - Strict bounds */
> > + {.expected = {.tv_sec = -1, .tv_nsec = 0},
> > + .observed = {.tv_sec = -1, .tv_nsec = -20000},
> > + .upper_bound = 1.00002, .lower_bound = 1.0000191, .result = 1,
> > + },
> > + /* 11 - Strict bounds with loose upper bound */
> > + {.expected = {.tv_sec = 1, .tv_nsec = 20000},
> > + .observed = {.tv_sec = 1, .tv_nsec = 30000},
> > + .upper_bound = 1.0000100000, .lower_bound = 1.0000099998, .result = 1,
> > + },
> > + /* 12 - Strict bounds with loose lower bound */
> > + {.expected = {.tv_sec = 1, .tv_nsec = 20000},
> > + .observed = {.tv_sec = 1, .tv_nsec = 30000},
> > + .upper_bound = 1.0000099999, .lower_bound = 1.00000999979, .result = 1,
> > + },
> > + /* 13 - Strict bounds highest precision */
> > + {.expected = {.tv_sec = 1, .tv_nsec = 20000},
> > + .observed = {.tv_sec = 1, .tv_nsec = 30000},
> > + .upper_bound = 1.00000999980001, .lower_bound = 1.00000999979999, .result = 1,
> > + },
> > + /* Maximum/Minimum long values */
> > + /* 14 */
> > + {.expected = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ - 1},
> > + .observed = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ - 2},
> > + .upper_bound = 1, .lower_bound = .9, .result = 1,
> > + },
> > + /* 15 - support_timespec_ns overflow */
> > + {.expected = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> > + .observed = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> > + .upper_bound = 1, .lower_bound = 1, .result = 1,
> > + },
> > + /* 16 - support_timespec_ns overflow + underflow */
> > + {.expected = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> > + .observed = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> > + .upper_bound = 1, .lower_bound = 1, .result = 0,
> > + },
> > + /* 17 - support_timespec_ns underflow */
> > + {.expected = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> > + .observed = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> > + .upper_bound = 1, .lower_bound = 1, .result = 1,
> > + },
> > + /* 18 - support_timespec_ns underflow + overflow */
> > + {.expected = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> > + .observed = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> > + .upper_bound = 1, .lower_bound = 1, .result = 0,
> > + },
> > + /* 19 - Biggest division */
> > + {.expected = {.tv_sec = LONG_MAX / TIMESPEC_HZ , .tv_nsec = TIMESPEC_HZ - 1},
> > + .observed = {.tv_sec = 0, .tv_nsec = 1},
> > + .upper_bound = 1, .lower_bound = 1.0842021724855044e-19, .result = 1,
> > + },
> > + /* 20 - Lowest division */
> > + {.expected = {.tv_sec = 0, .tv_nsec = 1},
> > + .observed = {.tv_sec = LONG_MAX / TIMESPEC_HZ , .tv_nsec = TIMESPEC_HZ - 1},
> > + .upper_bound = LONG_MAX, .lower_bound = 1, .result = 1,
> > + },
> > +};
> > +
> > +static int
> > +do_test (void)
> > +{
> > + int i = 0;
> > + int ntests = sizeof (ns_cases) / sizeof (ns_cases[0]);
> > +
> > + printf("Testing support_timespec_ns\n");
> > + for (i = 0; i < ntests; i++)
> > + {
> > + TEST_COMPARE (support_timespec_ns (ns_cases[i].time),
> > + ns_cases[i].time_ns);
> > + }
> > +
> > + ntests = sizeof (norm_cases) / sizeof (norm_cases[0]);
> > + struct timespec result;
> > + printf("Testing support_timespec_normalize\n");
> > + for (i = 0; i < ntests; i++)
> > + {
> > + result = support_timespec_normalize (norm_cases[i].time);
> > + TEST_COMPARE (norm_cases[i].norm.tv_sec, result.tv_sec);
> > + TEST_COMPARE (norm_cases[i].norm.tv_nsec, result.tv_nsec);
> > + }
> > +
> > + ntests = sizeof (check_cases) / sizeof (check_cases[0]);
> > + printf("Testing support_timespec_check_in_range\n");
> > + for (i = 0; i < ntests; i++)
> > + {
> > + /* Its hard to find which test failed with just the TEST_COMPARE report.
> > + So here we print every running testcase as well. */
> > + printf("Test case %d\n", i);
> > + TEST_COMPARE (support_timespec_check_in_range
> > + (check_cases[i].expected, check_cases[i].observed,
> > + check_cases[i].lower_bound,
> > + check_cases[i].upper_bound), check_cases[i].result);
> > + }
> > + return 0;
> > +}
> > +
> > +#include <support/test-driver.c>
> > diff --git a/time/tst-cpuclock1.c b/time/tst-cpuclock1.c
> > index 0120906f23..1ac611a92b 100644
> > --- a/time/tst-cpuclock1.c
> > +++ b/time/tst-cpuclock1.c
> > @@ -26,6 +26,7 @@
> > #include <signal.h>
> > #include <stdint.h>
> > #include <sys/wait.h>
> > +#include <support/timespec.h>
> >
> > /* This function is intended to rack up both user and system time. */
> > static void
> > @@ -155,16 +156,12 @@ do_test (void)
> > printf ("live PID %d after sleep => %ju.%.9ju\n",
> > child, (uintmax_t) after.tv_sec, (uintmax_t) after.tv_nsec);
> >
> > - struct timespec diff = { .tv_sec = after.tv_sec - before.tv_sec,
> > - .tv_nsec = after.tv_nsec - before.tv_nsec };
> > - if (diff.tv_nsec < 0)
> > - {
> > - --diff.tv_sec;
> > - diff.tv_nsec += 1000000000;
> > - }
> > - if (diff.tv_sec != 0
> > - || diff.tv_nsec > 600000000
> > - || diff.tv_nsec < 100000000)
> > + /* The bound values are empirically defined by testing this code over high cpu
> > + usage and different nice values. Of all the values we keep the 90th
> > + percentile of values and use those values for our testing allowed range. */
> > + struct timespec diff = timespec_sub (support_timespec_normalize (after),
> > + support_timespec_normalize (before));
> > + if (!support_timespec_check_in_range (sleeptime, diff, .9, 1.1))
> > {
> > printf ("before - after %ju.%.9ju outside reasonable range\n",
> > (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> > @@ -194,19 +191,16 @@ do_test (void)
> > }
> > else
> > {
> > - struct timespec d = { .tv_sec = afterns.tv_sec - after.tv_sec,
> > - .tv_nsec = afterns.tv_nsec - after.tv_nsec };
> > - if (d.tv_nsec < 0)
> > - {
> > - --d.tv_sec;
> > - d.tv_nsec += 1000000000;
> > - }
> > - if (d.tv_sec > 0
> > - || d.tv_nsec < sleeptime.tv_nsec
> > - || d.tv_nsec > sleeptime.tv_nsec * 2)
> > + /* The bound values are empirically defined by testing this code over
> > + high cpu usage and different nice values. Of all the values we keep
> > + the 90th percentile of values and use those values for our testing
> > + allowed range. */
> > + diff = timespec_sub (support_timespec_normalize (afterns),
> > + support_timespec_normalize (after));
> > + if (!support_timespec_check_in_range (sleeptime, diff, .9, 1.2))
> > {
> > printf ("nanosleep time %ju.%.9ju outside reasonable range\n",
> > - (uintmax_t) d.tv_sec, (uintmax_t) d.tv_nsec);
> > + (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> > result = 1;
> > }
> > }
> > @@ -240,15 +234,13 @@ do_test (void)
> > /* Should be close to 0.6. */
> > printf ("dead PID %d => %ju.%.9ju\n",
> > child, (uintmax_t) dead.tv_sec, (uintmax_t) dead.tv_nsec);
> > -
> > - diff.tv_sec = dead.tv_sec - after.tv_sec;
> > - diff.tv_nsec = dead.tv_nsec - after.tv_nsec;
> > - if (diff.tv_nsec < 0)
> > - {
> > - --diff.tv_sec;
> > - diff.tv_nsec += 1000000000;
> > - }
> > - if (diff.tv_sec != 0 || diff.tv_nsec > 200000000)
> > + /* The bound values are empirically defined by testing this code over high cpu
> > + usage and different nice values. Of all the values we keep the 90th
> > + percentile of values and use those values for our testing allowed range. */
> > + diff = timespec_sub (support_timespec_normalize (dead),
> > + support_timespec_normalize (after));
> > + sleeptime.tv_nsec = 100000000;
> > + if (!support_timespec_check_in_range (sleeptime, diff, .9, 1.2))
> > {
> > printf ("dead - after %ju.%.9ju outside reasonable range\n",
> > (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> > --
> > 2.26.2
> >
^ permalink raw reply [flat|nested] 44+ messages in thread
* Re: [PATCH v10] Fix time/tst-cpuclock1 intermitent failures
2020-06-12 15:28 ` [PATCH v10] " Lucas A. M. Magalhaes via Libc-alpha
2020-06-25 17:26 ` Lucas A. M. Magalhaes via Libc-alpha
@ 2020-07-07 20:12 ` Carlos O'Donell via Libc-alpha
2020-07-10 23:07 ` Tulio Magno Quites Machado Filho
1 sibling, 1 reply; 44+ messages in thread
From: Carlos O'Donell via Libc-alpha @ 2020-07-07 20:12 UTC (permalink / raw)
To: Lucas A. M. Magalhaes, libc-alpha
On 6/12/20 11:28 AM, Lucas A. M. Magalhaes wrote:
> This test fails intermittently in systems with heavy load as
> CLOCK_PROCESS_CPUTIME_ID is subject to scheduler pressure. Thus the
> test boundaries were relaxed to keep it from failing on such systems.
>
> A refactor of the spent time checking was made with some support
> functions. With the advantage to representing time jitter in percent
> of the target.
>
> The values used by the test boundaries are all empirical.
OK for master. I'd like to see this fixed in glibc 2.32.
Thank you for fixing the test case!
Reviewed-by: Carlos O'Donell <carlos@redhat.com>
> ---
>
> changes on V10:
> Change comments
>
> changes on V9:
> Add new testcases
> Fix support/tst-timespec do_run
> Add comments
> Change boundaries
>
> changes on V8:
> Add support_timespec_ns
> Add more tests
>
> This list of changes where getting to long.
Thank you for your patience.
> ---
> support/Makefile | 1 +
> support/timespec.c | 64 +++++++++
> support/timespec.h | 8 ++
> support/tst-timespec.c | 320 +++++++++++++++++++++++++++++++++++++++++
> time/tst-cpuclock1.c | 52 +++----
> 5 files changed, 415 insertions(+), 30 deletions(-)
> create mode 100644 support/tst-timespec.c
>
> diff --git a/support/Makefile b/support/Makefile
> index 51484310cd..914242d866 100644
> --- a/support/Makefile
> +++ b/support/Makefile
> @@ -236,6 +236,7 @@ tests = \
> tst-test_compare \
> tst-test_compare_blob \
> tst-test_compare_string \
> + tst-timespec \
> tst-xreadlink \
> tst-xsigstack \
>
> diff --git a/support/timespec.c b/support/timespec.c
> index ea6b947546..9f5449e49e 100644
> --- a/support/timespec.c
> +++ b/support/timespec.c
> @@ -19,6 +19,8 @@
> #include <support/timespec.h>
> #include <stdio.h>
> #include <stdint.h>
> +#include <assert.h>
> +#include <intprops.h>
>
> void
> test_timespec_before_impl (const char *file, int line,
> @@ -57,3 +59,65 @@ test_timespec_equal_or_after_impl (const char *file, int line,
> (intmax_t) diff.tv_sec, (intmax_t) diff.tv_nsec);
> }
> }
> +
> +/* Convert TIME to nanoseconds stored in a long.
> + Returns long maximum or minimum if the conversion overflows
> + or underflows, respectively. */
> +long
> +support_timespec_ns (struct timespec time)
> +{
> + long time_ns;
> + if (INT_MULTIPLY_WRAPV(time.tv_sec, TIMESPEC_HZ, &time_ns))
> + {
> + return (time.tv_sec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long);
> + }
> + if (INT_ADD_WRAPV(time_ns, time.tv_nsec, &time_ns))
> + {
> + return (time.tv_nsec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long);
> + }
> + return time_ns;
> +}
> +
> +/* Returns time normalized timespec with .tv_nsec < TIMESPEC_HZ
> + and the whole seconds added to .tv_sec. If an overflow or
> + underflow occurs the values are clamped to its maximum or
> + minimum respectively. */
> +struct timespec
> +support_timespec_normalize (struct timespec time)
> +{
> + struct timespec norm;
> + if (INT_ADD_WRAPV (time.tv_sec, (time.tv_nsec / TIMESPEC_HZ), &norm.tv_sec))
> + {
> + norm.tv_sec = (time.tv_nsec < 0) ? TYPE_MINIMUM (time_t): TYPE_MAXIMUM (time_t);
> + norm.tv_nsec = (time.tv_nsec < 0) ? -1 * (TIMESPEC_HZ - 1) : TIMESPEC_HZ - 1;
> + return norm;
> + }
> + norm.tv_nsec = time.tv_nsec % TIMESPEC_HZ;
> + return norm;
> +}
> +
> +/* Returns TRUE if the observed time is within the given percentage
> + bounds of the expected time, and FALSE otherwise.
> + For example the call
> +
> + support_timespec_check_in_range(expected, observed, 0.5, 1.2);
> +
> + will check if
> +
> + 0.5 of expected <= observed <= 1.2 of expected
> +
> + In other words it will check if observed time is within 50% to
> + 120% of the expected time. */
> +int
> +support_timespec_check_in_range (struct timespec expected, struct timespec observed,
> + double lower_bound, double upper_bound)
> +{
> + assert (upper_bound >= lower_bound);
> + long expected_norm, observed_norm;
> + expected_norm = support_timespec_ns (expected);
> + /* Don't divide by zero */
> + assert(expected_norm != 0);
> + observed_norm = support_timespec_ns (observed);
> + double ratio = (double)observed_norm / expected_norm;
> + return (lower_bound <= ratio && ratio <= upper_bound);
> +}
> diff --git a/support/timespec.h b/support/timespec.h
> index c5852dfe75..fd5466745d 100644
> --- a/support/timespec.h
> +++ b/support/timespec.h
> @@ -48,6 +48,14 @@ void test_timespec_equal_or_after_impl (const char *file, int line,
> const struct timespec left,
> const struct timespec right);
>
> +long support_timespec_ns (struct timespec time);
> +
> +struct timespec support_timespec_normalize (struct timespec time);
> +
> +int support_timespec_check_in_range (struct timespec expected, struct timespec observed,
> + double lower_bound, double upper_bound);
> +
> +
> /* Check that the timespec on the left represents a time before the
> time on the right. */
> #define TEST_TIMESPEC_BEFORE(left, right) \
> diff --git a/support/tst-timespec.c b/support/tst-timespec.c
> new file mode 100644
> index 0000000000..71423555a9
> --- /dev/null
> +++ b/support/tst-timespec.c
> @@ -0,0 +1,320 @@
> +/* Test for support_timespec_check_in_range function.
> + Copyright (C) 2020 Free Software Foundation, Inc.
> + This file is part of the GNU C Library.
> +
> + The GNU C Library is free software; you can redistribute it and/or
> + modify it under the terms of the GNU Lesser General Public
> + License as published by the Free Software Foundation; either
> + version 2.1 of the License, or (at your option) any later version.
> +
> + The GNU C Library is distributed in the hope that it will be useful,
> + but WITHOUT ANY WARRANTY; without even the implied warranty of
> + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> + Lesser General Public License for more details.
> +
> + You should have received a copy of the GNU Lesser General Public
> + License along with the GNU C Library; if not, see
> + <https://www.gnu.org/licenses/>. */
> +
> +#include <support/timespec.h>
> +#include <support/check.h>
> +#include <limits.h>
> +
> +#define TIMESPEC_HZ 1000000000
> +
> +struct timespec_ns_test_case
> +{
> + struct timespec time;
> + long time_ns;
> +};
> +
> +struct timespec_norm_test_case
> +{
> + struct timespec time;
> + struct timespec norm;
> +};
> +
> +struct timespec_test_case
> +{
> + struct timespec expected;
> + struct timespec observed;
> + double upper_bound;
> + double lower_bound;
> + int result;
> +};
> +
> +/* Test cases for timespec_ns */
> +struct timespec_ns_test_case ns_cases[] = {
> + {.time = {.tv_sec = 0, .tv_nsec = 0},
> + .time_ns = 0,
> + },
> + {.time = {.tv_sec = 0, .tv_nsec = 1},
> + .time_ns = 1,
> + },
> + {.time = {.tv_sec = 1, .tv_nsec = 0},
> + .time_ns = TIMESPEC_HZ,
> + },
> + {.time = {.tv_sec = 1, .tv_nsec = 1},
> + .time_ns = TIMESPEC_HZ + 1,
> + },
> + {.time = {.tv_sec = 0, .tv_nsec = -1},
> + .time_ns = -1,
> + },
> + {.time = {.tv_sec = -1, .tv_nsec = 0},
> + .time_ns = -TIMESPEC_HZ,
> + },
> + {.time = {.tv_sec = -1, .tv_nsec = -1},
> + .time_ns = -TIMESPEC_HZ - 1,
> + },
> + {.time = {.tv_sec = 1, .tv_nsec = -1},
> + .time_ns = TIMESPEC_HZ - 1,
> + },
> + {.time = {.tv_sec = -1, .tv_nsec = 1},
> + .time_ns = -TIMESPEC_HZ + 1,
> + },
> + /* Overflow bondary by 2 */
> + {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ, .tv_nsec = LONG_MAX%TIMESPEC_HZ - 1},
> + .time_ns = LONG_MAX - 1,
> + },
> + /* Overflow bondary */
> + {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ, .tv_nsec = LONG_MAX%TIMESPEC_HZ},
> + .time_ns = LONG_MAX,
> + },
> + /* Underflow bondary by 1 */
> + {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ, .tv_nsec = LONG_MIN%TIMESPEC_HZ + 1},
> + .time_ns = LONG_MIN + 1,
> + },
> + /* Underflow bondary */
> + {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ, .tv_nsec = LONG_MIN%TIMESPEC_HZ},
> + .time_ns = LONG_MIN,
> + },
> + /* Multiplication overflow */
> + {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ + 1, .tv_nsec = 1},
> + .time_ns = LONG_MAX,
> + },
> + /* Multiplication underflow */
> + {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ - 1, .tv_nsec = -1},
> + .time_ns = LONG_MIN,
> + },
> + /* Sum overflows */
> + {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ, .tv_nsec = LONG_MAX%TIMESPEC_HZ + 1},
> + .time_ns = LONG_MAX,
> + },
> + /* Sum underflow */
> + {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ, .tv_nsec = LONG_MIN%TIMESPEC_HZ - 1},
> + .time_ns = LONG_MIN,
> + }
> +};
> +
> +/* Test cases for timespec_norm */
> +struct timespec_norm_test_case norm_cases[] = {
> + /* Positive cases */
> + {.time = {.tv_sec = 0, .tv_nsec = 0},
> + .norm = {.tv_sec = 0, .tv_nsec = 0}
> + },
> + {.time = {.tv_sec = 1, .tv_nsec = 0},
> + .norm = {.tv_sec = 1, .tv_nsec = 0}
> + },
> + {.time = {.tv_sec = 0, .tv_nsec = 1},
> + .norm = {.tv_sec = 0, .tv_nsec = 1}
> + },
> + {.time = {.tv_sec = 0, .tv_nsec = TIMESPEC_HZ},
> + .norm = {.tv_sec = 1, .tv_nsec = 0}
> + },
> + {.time = {.tv_sec = 0, .tv_nsec = TIMESPEC_HZ + 1},
> + .norm = {.tv_sec = 1, .tv_nsec = 1}
> + },
> + {.time = {.tv_sec = 1, .tv_nsec = TIMESPEC_HZ},
> + .norm = {.tv_sec = 2, .tv_nsec = 0}
> + },
> + {.time = {.tv_sec = 1, .tv_nsec = TIMESPEC_HZ + 1},
> + .norm = {.tv_sec = 2, .tv_nsec = 1}
> + },
> + /* Negative cases */
> + {.time = {.tv_sec = 0, .tv_nsec = -TIMESPEC_HZ},
> + .norm = {.tv_sec = -1, .tv_nsec = 0}
> + },
> + {.time = {.tv_sec = 0, .tv_nsec = -TIMESPEC_HZ - 1},
> + .norm = {.tv_sec = -1, .tv_nsec = -1}
> + },
> + {.time = {.tv_sec = -1, .tv_nsec = -TIMESPEC_HZ},
> + .norm = {.tv_sec = -2, .tv_nsec = 0}
> + },
> + {.time = {.tv_sec = -1, .tv_nsec = -TIMESPEC_HZ - 1},
> + .norm = {.tv_sec = -2, .tv_nsec = -1}
> + },
> + /* Overflow bondary by 2 */
> + {.time = {.tv_sec = LONG_MAX - 2, .tv_nsec = TIMESPEC_HZ + 1},
> + .norm = {.tv_sec = LONG_MAX - 1, 1},
> + },
> + /* Overflow bondary by 1 */
> + {.time = {.tv_sec = LONG_MAX - 1, .tv_nsec = TIMESPEC_HZ + 1},
> + .norm = {.tv_sec = LONG_MAX, .tv_nsec = 1},
> + },
> + /* Underflow bondary by 2 */
> + {.time = {.tv_sec = LONG_MIN + 2, .tv_nsec = -TIMESPEC_HZ - 1},
> + .norm = {.tv_sec = LONG_MIN + 1, -1},
> + },
> + /* Underflow bondary by 1 */
> + {.time = {.tv_sec = LONG_MIN + 1, .tv_nsec = -TIMESPEC_HZ - 1},
> + .norm = {.tv_sec = LONG_MIN, .tv_nsec = -1},
> + },
> + /* SUM overflow */
> + {.time = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> + .norm = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ - 1},
> + },
> + /* SUM underflow */
> + {.time = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> + .norm = {.tv_sec = LONG_MIN, .tv_nsec = -1 * (TIMESPEC_HZ - 1)},
> + }
> +};
> +
> +/* Test cases for timespec_check_in_range */
> +struct timespec_test_case check_cases[] = {
> + /* 0 - In range */
> + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> + .observed = {.tv_sec = 1, .tv_nsec = 0},
> + .upper_bound = 1, .lower_bound = 1, .result = 1,
> + },
> + /* 1 - Out of range */
> + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> + .observed = {.tv_sec = 2, .tv_nsec = 0},
> + .upper_bound = 1, .lower_bound = 1, .result = 0,
> + },
> + /* 2 - Upper Bound */
> + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> + .observed = {.tv_sec = 2, .tv_nsec = 0},
> + .upper_bound = 2, .lower_bound = 1, .result = 1,
> + },
> + /* 3 - Lower Bound */
> + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> + .observed = {.tv_sec = 0, .tv_nsec = 0},
> + .upper_bound = 1, .lower_bound = 0, .result = 1,
> + },
> + /* 4 - Out of range by nanosecs */
> + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> + .observed = {.tv_sec = 1, .tv_nsec = 500},
> + .upper_bound = 1, .lower_bound = 1, .result = 0,
> + },
> + /* 5 - In range by nanosecs */
> + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> + .observed = {.tv_sec = 1, .tv_nsec = 50000},
> + .upper_bound = 1.3, .lower_bound = 1, .result = 1,
> + },
> + /* 6 - Big nanosecs */
> + {.expected = {.tv_sec = 1, .tv_nsec = 0},
> + .observed = {.tv_sec = 0, .tv_nsec = 4000000},
> + .upper_bound = 1, .lower_bound = .001, .result = 1,
> + },
> + /* 7 - In range Negative values */
> + {.expected = {.tv_sec = -1, .tv_nsec = 0},
> + .observed = {.tv_sec = -1, .tv_nsec = 0},
> + .upper_bound = 1, .lower_bound = 1, .result = 1,
> + },
> + /* 8 - Out of range Negative values */
> + {.expected = {.tv_sec = -1, .tv_nsec = 0},
> + .observed = {.tv_sec = -1, .tv_nsec = 0},
> + .upper_bound = -1, .lower_bound = -1, .result = 0,
> + },
> + /* 9 - Negative values with negative nanosecs */
> + {.expected = {.tv_sec = -1, .tv_nsec = 0},
> + .observed = {.tv_sec = -1, .tv_nsec = -2000},
> + .upper_bound = 1, .lower_bound = 1, .result = 0,
> + },
> + /* 10 - Strict bounds */
> + {.expected = {.tv_sec = -1, .tv_nsec = 0},
> + .observed = {.tv_sec = -1, .tv_nsec = -20000},
> + .upper_bound = 1.00002, .lower_bound = 1.0000191, .result = 1,
> + },
> + /* 11 - Strict bounds with loose upper bound */
> + {.expected = {.tv_sec = 1, .tv_nsec = 20000},
> + .observed = {.tv_sec = 1, .tv_nsec = 30000},
> + .upper_bound = 1.0000100000, .lower_bound = 1.0000099998, .result = 1,
> + },
> + /* 12 - Strict bounds with loose lower bound */
> + {.expected = {.tv_sec = 1, .tv_nsec = 20000},
> + .observed = {.tv_sec = 1, .tv_nsec = 30000},
> + .upper_bound = 1.0000099999, .lower_bound = 1.00000999979, .result = 1,
> + },
> + /* 13 - Strict bounds highest precision */
> + {.expected = {.tv_sec = 1, .tv_nsec = 20000},
> + .observed = {.tv_sec = 1, .tv_nsec = 30000},
> + .upper_bound = 1.00000999980001, .lower_bound = 1.00000999979999, .result = 1,
> + },
> + /* Maximum/Minimum long values */
> + /* 14 */
> + {.expected = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ - 1},
> + .observed = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ - 2},
> + .upper_bound = 1, .lower_bound = .9, .result = 1,
> + },
> + /* 15 - support_timespec_ns overflow */
> + {.expected = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> + .observed = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> + .upper_bound = 1, .lower_bound = 1, .result = 1,
> + },
> + /* 16 - support_timespec_ns overflow + underflow */
> + {.expected = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> + .observed = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> + .upper_bound = 1, .lower_bound = 1, .result = 0,
> + },
> + /* 17 - support_timespec_ns underflow */
> + {.expected = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> + .observed = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> + .upper_bound = 1, .lower_bound = 1, .result = 1,
> + },
> + /* 18 - support_timespec_ns underflow + overflow */
> + {.expected = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> + .observed = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> + .upper_bound = 1, .lower_bound = 1, .result = 0,
> + },
> + /* 19 - Biggest division */
> + {.expected = {.tv_sec = LONG_MAX / TIMESPEC_HZ , .tv_nsec = TIMESPEC_HZ - 1},
> + .observed = {.tv_sec = 0, .tv_nsec = 1},
> + .upper_bound = 1, .lower_bound = 1.0842021724855044e-19, .result = 1,
> + },
> + /* 20 - Lowest division */
> + {.expected = {.tv_sec = 0, .tv_nsec = 1},
> + .observed = {.tv_sec = LONG_MAX / TIMESPEC_HZ , .tv_nsec = TIMESPEC_HZ - 1},
> + .upper_bound = LONG_MAX, .lower_bound = 1, .result = 1,
> + },
> +};
> +
> +static int
> +do_test (void)
> +{
> + int i = 0;
> + int ntests = sizeof (ns_cases) / sizeof (ns_cases[0]);
> +
> + printf("Testing support_timespec_ns\n");
> + for (i = 0; i < ntests; i++)
> + {
> + TEST_COMPARE (support_timespec_ns (ns_cases[i].time),
> + ns_cases[i].time_ns);
> + }
> +
> + ntests = sizeof (norm_cases) / sizeof (norm_cases[0]);
> + struct timespec result;
> + printf("Testing support_timespec_normalize\n");
> + for (i = 0; i < ntests; i++)
> + {
> + result = support_timespec_normalize (norm_cases[i].time);
> + TEST_COMPARE (norm_cases[i].norm.tv_sec, result.tv_sec);
> + TEST_COMPARE (norm_cases[i].norm.tv_nsec, result.tv_nsec);
> + }
> +
> + ntests = sizeof (check_cases) / sizeof (check_cases[0]);
> + printf("Testing support_timespec_check_in_range\n");
> + for (i = 0; i < ntests; i++)
> + {
> + /* Its hard to find which test failed with just the TEST_COMPARE report.
> + So here we print every running testcase as well. */
> + printf("Test case %d\n", i);
> + TEST_COMPARE (support_timespec_check_in_range
> + (check_cases[i].expected, check_cases[i].observed,
> + check_cases[i].lower_bound,
> + check_cases[i].upper_bound), check_cases[i].result);
> + }
> + return 0;
> +}
> +
> +#include <support/test-driver.c>
> diff --git a/time/tst-cpuclock1.c b/time/tst-cpuclock1.c
> index 0120906f23..1ac611a92b 100644
> --- a/time/tst-cpuclock1.c
> +++ b/time/tst-cpuclock1.c
> @@ -26,6 +26,7 @@
> #include <signal.h>
> #include <stdint.h>
> #include <sys/wait.h>
> +#include <support/timespec.h>
>
> /* This function is intended to rack up both user and system time. */
> static void
> @@ -155,16 +156,12 @@ do_test (void)
> printf ("live PID %d after sleep => %ju.%.9ju\n",
> child, (uintmax_t) after.tv_sec, (uintmax_t) after.tv_nsec);
>
> - struct timespec diff = { .tv_sec = after.tv_sec - before.tv_sec,
> - .tv_nsec = after.tv_nsec - before.tv_nsec };
> - if (diff.tv_nsec < 0)
> - {
> - --diff.tv_sec;
> - diff.tv_nsec += 1000000000;
> - }
> - if (diff.tv_sec != 0
> - || diff.tv_nsec > 600000000
> - || diff.tv_nsec < 100000000)
> + /* The bound values are empirically defined by testing this code over high cpu
> + usage and different nice values. Of all the values we keep the 90th
> + percentile of values and use those values for our testing allowed range. */
> + struct timespec diff = timespec_sub (support_timespec_normalize (after),
> + support_timespec_normalize (before));
> + if (!support_timespec_check_in_range (sleeptime, diff, .9, 1.1))
> {
> printf ("before - after %ju.%.9ju outside reasonable range\n",
> (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> @@ -194,19 +191,16 @@ do_test (void)
> }
> else
> {
> - struct timespec d = { .tv_sec = afterns.tv_sec - after.tv_sec,
> - .tv_nsec = afterns.tv_nsec - after.tv_nsec };
> - if (d.tv_nsec < 0)
> - {
> - --d.tv_sec;
> - d.tv_nsec += 1000000000;
> - }
> - if (d.tv_sec > 0
> - || d.tv_nsec < sleeptime.tv_nsec
> - || d.tv_nsec > sleeptime.tv_nsec * 2)
> + /* The bound values are empirically defined by testing this code over
> + high cpu usage and different nice values. Of all the values we keep
> + the 90th percentile of values and use those values for our testing
> + allowed range. */
> + diff = timespec_sub (support_timespec_normalize (afterns),
> + support_timespec_normalize (after));
> + if (!support_timespec_check_in_range (sleeptime, diff, .9, 1.2))
> {
> printf ("nanosleep time %ju.%.9ju outside reasonable range\n",
> - (uintmax_t) d.tv_sec, (uintmax_t) d.tv_nsec);
> + (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> result = 1;
> }
> }
> @@ -240,15 +234,13 @@ do_test (void)
> /* Should be close to 0.6. */
> printf ("dead PID %d => %ju.%.9ju\n",
> child, (uintmax_t) dead.tv_sec, (uintmax_t) dead.tv_nsec);
> -
> - diff.tv_sec = dead.tv_sec - after.tv_sec;
> - diff.tv_nsec = dead.tv_nsec - after.tv_nsec;
> - if (diff.tv_nsec < 0)
> - {
> - --diff.tv_sec;
> - diff.tv_nsec += 1000000000;
> - }
> - if (diff.tv_sec != 0 || diff.tv_nsec > 200000000)
> + /* The bound values are empirically defined by testing this code over high cpu
> + usage and different nice values. Of all the values we keep the 90th
> + percentile of values and use those values for our testing allowed range. */
> + diff = timespec_sub (support_timespec_normalize (dead),
> + support_timespec_normalize (after));
> + sleeptime.tv_nsec = 100000000;
> + if (!support_timespec_check_in_range (sleeptime, diff, .9, 1.2))
> {
> printf ("dead - after %ju.%.9ju outside reasonable range\n",
> (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
>
--
Cheers,
Carlos.
^ permalink raw reply [flat|nested] 44+ messages in thread* Re: [PATCH v10] Fix time/tst-cpuclock1 intermitent failures
2020-07-07 20:12 ` Carlos O'Donell via Libc-alpha
@ 2020-07-10 23:07 ` Tulio Magno Quites Machado Filho
2020-07-11 14:45 ` H.J. Lu via Libc-alpha
0 siblings, 1 reply; 44+ messages in thread
From: Tulio Magno Quites Machado Filho @ 2020-07-10 23:07 UTC (permalink / raw)
To: Carlos O'Donell, Lucas A. M. Magalhaes, libc-alpha
Carlos O'Donell via Libc-alpha <libc-alpha@sourceware.org> writes:
> OK for master. I'd like to see this fixed in glibc 2.32.
> Thank you for fixing the test case!
>
> Reviewed-by: Carlos O'Donell <carlos@redhat.com>
Pushed as 04deeaa9ea74b0679dfc9d9155a37b6425f19a9f.
Thanks!
--
Tulio Magno
^ permalink raw reply [flat|nested] 44+ messages in thread
* Re: [PATCH v10] Fix time/tst-cpuclock1 intermitent failures
2020-07-10 23:07 ` Tulio Magno Quites Machado Filho
@ 2020-07-11 14:45 ` H.J. Lu via Libc-alpha
2020-07-11 16:31 ` H.J. Lu via Libc-alpha
0 siblings, 1 reply; 44+ messages in thread
From: H.J. Lu via Libc-alpha @ 2020-07-11 14:45 UTC (permalink / raw)
To: Tulio Magno Quites Machado Filho; +Cc: GNU C Library
On Fri, Jul 10, 2020 at 4:10 PM Tulio Magno Quites Machado Filho
<tuliom@ascii.art.br> wrote:
>
> Carlos O'Donell via Libc-alpha <libc-alpha@sourceware.org> writes:
>
> > OK for master. I'd like to see this fixed in glibc 2.32.
> > Thank you for fixing the test case!
> >
> > Reviewed-by: Carlos O'Donell <carlos@redhat.com>
>
> Pushed as 04deeaa9ea74b0679dfc9d9155a37b6425f19a9f.
>
support/tst-timespec failed on i686 and x32:
Test case 10
tst-timespec.c:312: numeric comparison failure
left: 0 (0x0); from: support_timespec_check_in_range
(check_cases[i].expected, check_cases[i].observed,
check_cases[i].lower_bound, check_cases[i].upper_bound)
right: 1 (0x1); from: check_cases[i].result
Test case 11
--
H.J.
^ permalink raw reply [flat|nested] 44+ messages in thread
* Re: [PATCH v10] Fix time/tst-cpuclock1 intermitent failures
2020-07-11 14:45 ` H.J. Lu via Libc-alpha
@ 2020-07-11 16:31 ` H.J. Lu via Libc-alpha
2020-07-13 23:30 ` [PATCH] Correct timespec implementation [BZ #26232] H.J. Lu via Libc-alpha
0 siblings, 1 reply; 44+ messages in thread
From: H.J. Lu via Libc-alpha @ 2020-07-11 16:31 UTC (permalink / raw)
To: Tulio Magno Quites Machado Filho; +Cc: GNU C Library
On Sat, Jul 11, 2020 at 7:45 AM H.J. Lu <hjl.tools@gmail.com> wrote:
>
> On Fri, Jul 10, 2020 at 4:10 PM Tulio Magno Quites Machado Filho
> <tuliom@ascii.art.br> wrote:
> >
> > Carlos O'Donell via Libc-alpha <libc-alpha@sourceware.org> writes:
> >
> > > OK for master. I'd like to see this fixed in glibc 2.32.
> > > Thank you for fixing the test case!
> > >
> > > Reviewed-by: Carlos O'Donell <carlos@redhat.com>
> >
> > Pushed as 04deeaa9ea74b0679dfc9d9155a37b6425f19a9f.
> >
>
> support/tst-timespec failed on i686 and x32:
>
> Test case 10
> tst-timespec.c:312: numeric comparison failure
> left: 0 (0x0); from: support_timespec_check_in_range
> (check_cases[i].expected, check_cases[i].observed,
> check_cases[i].lower_bound, check_cases[i].upper_bound)
> right: 1 (0x1); from: check_cases[i].result
> Test case 11
>
Usage of long may be the problem.
--
H.J.
^ permalink raw reply [flat|nested] 44+ messages in thread
* [PATCH] Correct timespec implementation [BZ #26232]
2020-07-11 16:31 ` H.J. Lu via Libc-alpha
@ 2020-07-13 23:30 ` H.J. Lu via Libc-alpha
2020-07-14 2:35 ` Carlos O'Donell via Libc-alpha
2020-07-14 11:16 ` Florian Weimer via Libc-alpha
0 siblings, 2 replies; 44+ messages in thread
From: H.J. Lu via Libc-alpha @ 2020-07-13 23:30 UTC (permalink / raw)
To: Tulio Magno Quites Machado Filho; +Cc: GNU C Library
[-- Attachment #1: Type: text/plain, Size: 1731 bytes --]
On Sat, Jul 11, 2020 at 9:31 AM H.J. Lu <hjl.tools@gmail.com> wrote:
>
> On Sat, Jul 11, 2020 at 7:45 AM H.J. Lu <hjl.tools@gmail.com> wrote:
> >
> > On Fri, Jul 10, 2020 at 4:10 PM Tulio Magno Quites Machado Filho
> > <tuliom@ascii.art.br> wrote:
> > >
> > > Carlos O'Donell via Libc-alpha <libc-alpha@sourceware.org> writes:
> > >
> > > > OK for master. I'd like to see this fixed in glibc 2.32.
> > > > Thank you for fixing the test case!
> > > >
> > > > Reviewed-by: Carlos O'Donell <carlos@redhat.com>
> > >
> > > Pushed as 04deeaa9ea74b0679dfc9d9155a37b6425f19a9f.
> > >
> >
> > support/tst-timespec failed on i686 and x32:
> >
> > Test case 10
> > tst-timespec.c:312: numeric comparison failure
> > left: 0 (0x0); from: support_timespec_check_in_range
> > (check_cases[i].expected, check_cases[i].observed,
> > check_cases[i].lower_bound, check_cases[i].upper_bound)
> > right: 1 (0x1); from: check_cases[i].result
> > Test case 11
> >
>
> Usage of long may be the problem.
>
commit 04deeaa9ea74b0679dfc9d9155a37b6425f19a9f
Author: Lucas A. M. Magalhaes <lamm@linux.ibm.com>
Date: Fri Jul 10 19:41:06 2020 -0300
Fix time/tst-cpuclock1 intermitent failures
has 2 issues:
1. It assumes time_t == long which is false on x32.
2. tst-timespec.c is compiled without -fexcess-precision=standard which
generates incorrect results on i686 in support_timespec_check_in_range:
double ratio = (double)observed_norm / expected_norm;
return (lower_bound <= ratio && ratio <= upper_bound);
This patch does
1. Compile tst-timespec.c with -fexcess-precision=standard.
2. Replace long with time_t.
3. Replace LONG_MIN and LONG_MAX with TYPE_MINIMUM (time_t) and
TYPE_MAXIMUM (time_t).
OK for master?
Thanks.
--
H.J.
[-- Attachment #2: 0001-Correct-timespec-implementation-BZ-26232.patch --]
[-- Type: text/x-patch, Size: 11377 bytes --]
From 3a3003d3a429035d7cfb8485c64a22cb9517ec48 Mon Sep 17 00:00:00 2001
From: "H.J. Lu" <hjl.tools@gmail.com>
Date: Mon, 13 Jul 2020 16:15:56 -0700
Subject: [PATCH] Correct timespec implementation [BZ #26232]
commit 04deeaa9ea74b0679dfc9d9155a37b6425f19a9f
Author: Lucas A. M. Magalhaes <lamm@linux.ibm.com>
Date: Fri Jul 10 19:41:06 2020 -0300
Fix time/tst-cpuclock1 intermitent failures
has 2 issues:
1. It assumes time_t == long which is false on x32.
2. tst-timespec.c is compiled without -fexcess-precision=standard which
generates incorrect results on i686 in support_timespec_check_in_range:
double ratio = (double)observed_norm / expected_norm;
return (lower_bound <= ratio && ratio <= upper_bound);
This patch does
1. Compile tst-timespec.c with -fexcess-precision=standard.
2. Replace long with time_t.
3. Replace LONG_MIN and LONG_MAX with TYPE_MINIMUM (time_t) and
TYPE_MAXIMUM (time_t).
---
support/Makefile | 2 +
support/timespec.c | 18 +++-----
support/timespec.h | 2 +-
support/tst-timespec.c | 98 ++++++++++++++++++++++++------------------
4 files changed, 66 insertions(+), 54 deletions(-)
diff --git a/support/Makefile b/support/Makefile
index e74e0dd519..94f84e01eb 100644
--- a/support/Makefile
+++ b/support/Makefile
@@ -196,6 +196,8 @@ CFLAGS-support_paths.c = \
-DROOTSBINDIR_PATH=\"$(rootsbindir)\" \
-DCOMPLOCALEDIR_PATH=\"$(complocaledir)\"
+CFLAGS-timespec.c += -fexcess-precision=standard
+
ifeq (,$(CXX))
LINKS_DSO_PROGRAM = links-dso-program-c
else
diff --git a/support/timespec.c b/support/timespec.c
index 9f5449e49e..edbdb165ec 100644
--- a/support/timespec.c
+++ b/support/timespec.c
@@ -60,21 +60,17 @@ test_timespec_equal_or_after_impl (const char *file, int line,
}
}
-/* Convert TIME to nanoseconds stored in a long.
- Returns long maximum or minimum if the conversion overflows
+/* Convert TIME to nanoseconds stored in a time_t.
+ Returns time_t maximum or minimum if the conversion overflows
or underflows, respectively. */
-long
+time_t
support_timespec_ns (struct timespec time)
{
- long time_ns;
+ time_t time_ns;
if (INT_MULTIPLY_WRAPV(time.tv_sec, TIMESPEC_HZ, &time_ns))
- {
- return (time.tv_sec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long);
- }
+ return time.tv_sec < 0 ? TYPE_MINIMUM(time_t) : TYPE_MAXIMUM(time_t);
if (INT_ADD_WRAPV(time_ns, time.tv_nsec, &time_ns))
- {
- return (time.tv_nsec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long);
- }
+ return time.tv_nsec < 0 ? TYPE_MINIMUM(time_t) : TYPE_MAXIMUM(time_t);
return time_ns;
}
@@ -113,7 +109,7 @@ support_timespec_check_in_range (struct timespec expected, struct timespec obser
double lower_bound, double upper_bound)
{
assert (upper_bound >= lower_bound);
- long expected_norm, observed_norm;
+ time_t expected_norm, observed_norm;
expected_norm = support_timespec_ns (expected);
/* Don't divide by zero */
assert(expected_norm != 0);
diff --git a/support/timespec.h b/support/timespec.h
index fd5466745d..1a6775a882 100644
--- a/support/timespec.h
+++ b/support/timespec.h
@@ -48,7 +48,7 @@ void test_timespec_equal_or_after_impl (const char *file, int line,
const struct timespec left,
const struct timespec right);
-long support_timespec_ns (struct timespec time);
+time_t support_timespec_ns (struct timespec time);
struct timespec support_timespec_normalize (struct timespec time);
diff --git a/support/tst-timespec.c b/support/tst-timespec.c
index 71423555a9..ac5ed228ba 100644
--- a/support/tst-timespec.c
+++ b/support/tst-timespec.c
@@ -19,13 +19,14 @@
#include <support/timespec.h>
#include <support/check.h>
#include <limits.h>
+#include <intprops.h>
#define TIMESPEC_HZ 1000000000
struct timespec_ns_test_case
{
struct timespec time;
- long time_ns;
+ time_t time_ns;
};
struct timespec_norm_test_case
@@ -43,6 +44,9 @@ struct timespec_test_case
int result;
};
+#define TIME_T_MIN TYPE_MINIMUM (time_t)
+#define TIME_T_MAX TYPE_MAXIMUM (time_t)
+
/* Test cases for timespec_ns */
struct timespec_ns_test_case ns_cases[] = {
{.time = {.tv_sec = 0, .tv_nsec = 0},
@@ -73,36 +77,42 @@ struct timespec_ns_test_case ns_cases[] = {
.time_ns = -TIMESPEC_HZ + 1,
},
/* Overflow bondary by 2 */
- {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ, .tv_nsec = LONG_MAX%TIMESPEC_HZ - 1},
- .time_ns = LONG_MAX - 1,
+ {.time = {.tv_sec = TIME_T_MAX / TIMESPEC_HZ,
+ .tv_nsec = TIME_T_MAX % TIMESPEC_HZ - 1},
+ .time_ns = TIME_T_MAX - 1,
},
/* Overflow bondary */
- {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ, .tv_nsec = LONG_MAX%TIMESPEC_HZ},
- .time_ns = LONG_MAX,
+ {.time = {.tv_sec = TIME_T_MAX / TIMESPEC_HZ,
+ .tv_nsec = TIME_T_MAX % TIMESPEC_HZ},
+ .time_ns = TIME_T_MAX,
},
/* Underflow bondary by 1 */
- {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ, .tv_nsec = LONG_MIN%TIMESPEC_HZ + 1},
- .time_ns = LONG_MIN + 1,
+ {.time = {.tv_sec = TIME_T_MIN / TIMESPEC_HZ,
+ .tv_nsec = TIME_T_MIN % TIMESPEC_HZ + 1},
+ .time_ns = TIME_T_MIN + 1,
},
/* Underflow bondary */
- {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ, .tv_nsec = LONG_MIN%TIMESPEC_HZ},
- .time_ns = LONG_MIN,
+ {.time = {.tv_sec = TIME_T_MIN / TIMESPEC_HZ,
+ .tv_nsec = TIME_T_MIN % TIMESPEC_HZ},
+ .time_ns = TIME_T_MIN,
},
/* Multiplication overflow */
- {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ + 1, .tv_nsec = 1},
- .time_ns = LONG_MAX,
+ {.time = {.tv_sec = TIME_T_MAX / TIMESPEC_HZ + 1, .tv_nsec = 1},
+ .time_ns = TIME_T_MAX,
},
/* Multiplication underflow */
- {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ - 1, .tv_nsec = -1},
- .time_ns = LONG_MIN,
+ {.time = {.tv_sec = TIME_T_MIN / TIMESPEC_HZ - 1, .tv_nsec = -1},
+ .time_ns = TIME_T_MIN,
},
/* Sum overflows */
- {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ, .tv_nsec = LONG_MAX%TIMESPEC_HZ + 1},
- .time_ns = LONG_MAX,
+ {.time = {.tv_sec = TIME_T_MAX / TIMESPEC_HZ,
+ .tv_nsec = TIME_T_MAX % TIMESPEC_HZ + 1},
+ .time_ns = TIME_T_MAX,
},
/* Sum underflow */
- {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ, .tv_nsec = LONG_MIN%TIMESPEC_HZ - 1},
- .time_ns = LONG_MIN,
+ {.time = {.tv_sec = TIME_T_MIN / TIMESPEC_HZ,
+ .tv_nsec = TIME_T_MIN % TIMESPEC_HZ - 1},
+ .time_ns = TIME_T_MIN,
}
};
@@ -144,28 +154,28 @@ struct timespec_norm_test_case norm_cases[] = {
.norm = {.tv_sec = -2, .tv_nsec = -1}
},
/* Overflow bondary by 2 */
- {.time = {.tv_sec = LONG_MAX - 2, .tv_nsec = TIMESPEC_HZ + 1},
- .norm = {.tv_sec = LONG_MAX - 1, 1},
+ {.time = {.tv_sec = TIME_T_MAX - 2, .tv_nsec = TIMESPEC_HZ + 1},
+ .norm = {.tv_sec = TIME_T_MAX - 1, 1},
},
/* Overflow bondary by 1 */
- {.time = {.tv_sec = LONG_MAX - 1, .tv_nsec = TIMESPEC_HZ + 1},
- .norm = {.tv_sec = LONG_MAX, .tv_nsec = 1},
+ {.time = {.tv_sec = TIME_T_MAX - 1, .tv_nsec = TIMESPEC_HZ + 1},
+ .norm = {.tv_sec = TIME_T_MAX, .tv_nsec = 1},
},
/* Underflow bondary by 2 */
- {.time = {.tv_sec = LONG_MIN + 2, .tv_nsec = -TIMESPEC_HZ - 1},
- .norm = {.tv_sec = LONG_MIN + 1, -1},
+ {.time = {.tv_sec = TIME_T_MIN + 2, .tv_nsec = -TIMESPEC_HZ - 1},
+ .norm = {.tv_sec = TIME_T_MIN + 1, -1},
},
/* Underflow bondary by 1 */
- {.time = {.tv_sec = LONG_MIN + 1, .tv_nsec = -TIMESPEC_HZ - 1},
- .norm = {.tv_sec = LONG_MIN, .tv_nsec = -1},
+ {.time = {.tv_sec = TIME_T_MIN + 1, .tv_nsec = -TIMESPEC_HZ - 1},
+ .norm = {.tv_sec = TIME_T_MIN, .tv_nsec = -1},
},
/* SUM overflow */
- {.time = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
- .norm = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ - 1},
+ {.time = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ},
+ .norm = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ - 1},
},
/* SUM underflow */
- {.time = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
- .norm = {.tv_sec = LONG_MIN, .tv_nsec = -1 * (TIMESPEC_HZ - 1)},
+ {.time = {.tv_sec = TIME_T_MIN, .tv_nsec = -TIMESPEC_HZ},
+ .norm = {.tv_sec = TIME_T_MIN, .tv_nsec = -1 * (TIMESPEC_HZ - 1)},
}
};
@@ -243,39 +253,41 @@ struct timespec_test_case check_cases[] = {
},
/* Maximum/Minimum long values */
/* 14 */
- {.expected = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ - 1},
- .observed = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ - 2},
+ {.expected = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ - 1},
+ .observed = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ - 2},
.upper_bound = 1, .lower_bound = .9, .result = 1,
},
/* 15 - support_timespec_ns overflow */
- {.expected = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
- .observed = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
+ {.expected = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ},
+ .observed = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ},
.upper_bound = 1, .lower_bound = 1, .result = 1,
},
/* 16 - support_timespec_ns overflow + underflow */
- {.expected = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
- .observed = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
+ {.expected = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ},
+ .observed = {.tv_sec = TIME_T_MIN, .tv_nsec = -TIMESPEC_HZ},
.upper_bound = 1, .lower_bound = 1, .result = 0,
},
/* 17 - support_timespec_ns underflow */
- {.expected = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
- .observed = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
+ {.expected = {.tv_sec = TIME_T_MIN, .tv_nsec = -TIMESPEC_HZ},
+ .observed = {.tv_sec = TIME_T_MIN, .tv_nsec = -TIMESPEC_HZ},
.upper_bound = 1, .lower_bound = 1, .result = 1,
},
/* 18 - support_timespec_ns underflow + overflow */
- {.expected = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
- .observed = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
+ {.expected = {.tv_sec = TIME_T_MIN, .tv_nsec = -TIMESPEC_HZ},
+ .observed = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ},
.upper_bound = 1, .lower_bound = 1, .result = 0,
},
/* 19 - Biggest division */
- {.expected = {.tv_sec = LONG_MAX / TIMESPEC_HZ , .tv_nsec = TIMESPEC_HZ - 1},
+ {.expected = {.tv_sec = TIME_T_MAX / TIMESPEC_HZ,
+ .tv_nsec = TIMESPEC_HZ - 1},
.observed = {.tv_sec = 0, .tv_nsec = 1},
.upper_bound = 1, .lower_bound = 1.0842021724855044e-19, .result = 1,
},
/* 20 - Lowest division */
{.expected = {.tv_sec = 0, .tv_nsec = 1},
- .observed = {.tv_sec = LONG_MAX / TIMESPEC_HZ , .tv_nsec = TIMESPEC_HZ - 1},
- .upper_bound = LONG_MAX, .lower_bound = 1, .result = 1,
+ .observed = {.tv_sec = TIME_T_MAX / TIMESPEC_HZ,
+ .tv_nsec = TIMESPEC_HZ - 1},
+ .upper_bound = TIME_T_MAX, .lower_bound = 1, .result = 1,
},
};
@@ -288,6 +300,7 @@ do_test (void)
printf("Testing support_timespec_ns\n");
for (i = 0; i < ntests; i++)
{
+ printf("Test case %d\n", i);
TEST_COMPARE (support_timespec_ns (ns_cases[i].time),
ns_cases[i].time_ns);
}
@@ -297,6 +310,7 @@ do_test (void)
printf("Testing support_timespec_normalize\n");
for (i = 0; i < ntests; i++)
{
+ printf("Test case %d\n", i);
result = support_timespec_normalize (norm_cases[i].time);
TEST_COMPARE (norm_cases[i].norm.tv_sec, result.tv_sec);
TEST_COMPARE (norm_cases[i].norm.tv_nsec, result.tv_nsec);
--
2.26.2
^ permalink raw reply related [flat|nested] 44+ messages in thread* Re: [PATCH] Correct timespec implementation [BZ #26232]
2020-07-13 23:30 ` [PATCH] Correct timespec implementation [BZ #26232] H.J. Lu via Libc-alpha
@ 2020-07-14 2:35 ` Carlos O'Donell via Libc-alpha
2020-07-14 11:16 ` Florian Weimer via Libc-alpha
1 sibling, 0 replies; 44+ messages in thread
From: Carlos O'Donell via Libc-alpha @ 2020-07-14 2:35 UTC (permalink / raw)
To: H.J. Lu, Tulio Magno Quites Machado Filho; +Cc: GNU C Library
On 7/13/20 7:30 PM, H.J. Lu wrote:
> On Sat, Jul 11, 2020 at 9:31 AM H.J. Lu <hjl.tools@gmail.com> wrote:
>>
>> On Sat, Jul 11, 2020 at 7:45 AM H.J. Lu <hjl.tools@gmail.com> wrote:
>>>
>>> On Fri, Jul 10, 2020 at 4:10 PM Tulio Magno Quites Machado Filho
>>> <tuliom@ascii.art.br> wrote:
>>>>
>>>> Carlos O'Donell via Libc-alpha <libc-alpha@sourceware.org> writes:
>>>>
>>>>> OK for master. I'd like to see this fixed in glibc 2.32.
>>>>> Thank you for fixing the test case!
>>>>>
>>>>> Reviewed-by: Carlos O'Donell <carlos@redhat.com>
>>>>
>>>> Pushed as 04deeaa9ea74b0679dfc9d9155a37b6425f19a9f.
>>>>
>>>
>>> support/tst-timespec failed on i686 and x32:
>>>
>>> Test case 10
>>> tst-timespec.c:312: numeric comparison failure
>>> left: 0 (0x0); from: support_timespec_check_in_range
>>> (check_cases[i].expected, check_cases[i].observed,
>>> check_cases[i].lower_bound, check_cases[i].upper_bound)
>>> right: 1 (0x1); from: check_cases[i].result
>>> Test case 11
>>>
>>
>> Usage of long may be the problem.
>>
>
> commit 04deeaa9ea74b0679dfc9d9155a37b6425f19a9f
> Author: Lucas A. M. Magalhaes <lamm@linux.ibm.com>
> Date: Fri Jul 10 19:41:06 2020 -0300
>
> Fix time/tst-cpuclock1 intermitent failures
>
> has 2 issues:
>
> 1. It assumes time_t == long which is false on x32.
> 2. tst-timespec.c is compiled without -fexcess-precision=standard which
> generates incorrect results on i686 in support_timespec_check_in_range:
>
> double ratio = (double)observed_norm / expected_norm;
> return (lower_bound <= ratio && ratio <= upper_bound);
>
> This patch does
>
> 1. Compile tst-timespec.c with -fexcess-precision=standard.
> 2. Replace long with time_t.
> 3. Replace LONG_MIN and LONG_MAX with TYPE_MINIMUM (time_t) and
> TYPE_MAXIMUM (time_t).
>
> OK for master?
OK for 2.32 with comment.
Reivewed-by: Carlos O'Donell <carlos@redhat.com>
> From 3a3003d3a429035d7cfb8485c64a22cb9517ec48 Mon Sep 17 00:00:00 2001
> From: "H.J. Lu" <hjl.tools@gmail.com>
> Date: Mon, 13 Jul 2020 16:15:56 -0700
> Subject: [PATCH] Correct timespec implementation [BZ #26232]
>
> commit 04deeaa9ea74b0679dfc9d9155a37b6425f19a9f
> Author: Lucas A. M. Magalhaes <lamm@linux.ibm.com>
> Date: Fri Jul 10 19:41:06 2020 -0300
>
> Fix time/tst-cpuclock1 intermitent failures
>
> has 2 issues:
>
> 1. It assumes time_t == long which is false on x32.
Thanks. I had no considered x32 during the review.
> 2. tst-timespec.c is compiled without -fexcess-precision=standard which
> generates incorrect results on i686 in support_timespec_check_in_range:
>
> double ratio = (double)observed_norm / expected_norm;
> return (lower_bound <= ratio && ratio <= upper_bound);
Yes, some of the tests have bounds which are quite tight. We could either
loosen the bounds or compile as you indicate. I'm OK either way. I'll
ack this patch.
> This patch does
>
> 1. Compile tst-timespec.c with -fexcess-precision=standard.
> 2. Replace long with time_t.
> 3. Replace LONG_MIN and LONG_MAX with TYPE_MINIMUM (time_t) and
> TYPE_MAXIMUM (time_t).
> ---
> support/Makefile | 2 +
> support/timespec.c | 18 +++-----
> support/timespec.h | 2 +-
> support/tst-timespec.c | 98 ++++++++++++++++++++++++------------------
> 4 files changed, 66 insertions(+), 54 deletions(-)
>
> diff --git a/support/Makefile b/support/Makefile
> index e74e0dd519..94f84e01eb 100644
> --- a/support/Makefile
> +++ b/support/Makefile
> @@ -196,6 +196,8 @@ CFLAGS-support_paths.c = \
> -DROOTSBINDIR_PATH=\"$(rootsbindir)\" \
> -DCOMPLOCALEDIR_PATH=\"$(complocaledir)\"
>
> +CFLAGS-timespec.c += -fexcess-precision=standard
OK with this comment:
# In support_timespec_check_in_range we may be passed a very
# tight range for which we should produce a correct result
# for expected being withing the observed range. The code
# uses double internally in support_timespec_check_in_range
# and for that computation we use -fexcess-precision=standard.
> +
> ifeq (,$(CXX))
> LINKS_DSO_PROGRAM = links-dso-program-c
> else
> diff --git a/support/timespec.c b/support/timespec.c
> index 9f5449e49e..edbdb165ec 100644
> --- a/support/timespec.c
> +++ b/support/timespec.c
> @@ -60,21 +60,17 @@ test_timespec_equal_or_after_impl (const char *file, int line,
> }
> }
>
> -/* Convert TIME to nanoseconds stored in a long.
> - Returns long maximum or minimum if the conversion overflows
> +/* Convert TIME to nanoseconds stored in a time_t.
> + Returns time_t maximum or minimum if the conversion overflows
OK.
> or underflows, respectively. */
> -long
> +time_t
> support_timespec_ns (struct timespec time)
> {
> - long time_ns;
> + time_t time_ns;
> if (INT_MULTIPLY_WRAPV(time.tv_sec, TIMESPEC_HZ, &time_ns))
> - {
> - return (time.tv_sec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long);
> - }
> + return time.tv_sec < 0 ? TYPE_MINIMUM(time_t) : TYPE_MAXIMUM(time_t);
> if (INT_ADD_WRAPV(time_ns, time.tv_nsec, &time_ns))
> - {
> - return (time.tv_nsec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long);
> - }
> + return time.tv_nsec < 0 ? TYPE_MINIMUM(time_t) : TYPE_MAXIMUM(time_t);
OK.
> return time_ns;
> }
>
> @@ -113,7 +109,7 @@ support_timespec_check_in_range (struct timespec expected, struct timespec obser
> double lower_bound, double upper_bound)
> {
> assert (upper_bound >= lower_bound);
> - long expected_norm, observed_norm;
> + time_t expected_norm, observed_norm;
OK.
> expected_norm = support_timespec_ns (expected);
> /* Don't divide by zero */
> assert(expected_norm != 0);
> diff --git a/support/timespec.h b/support/timespec.h
> index fd5466745d..1a6775a882 100644
> --- a/support/timespec.h
> +++ b/support/timespec.h
> @@ -48,7 +48,7 @@ void test_timespec_equal_or_after_impl (const char *file, int line,
> const struct timespec left,
> const struct timespec right);
>
> -long support_timespec_ns (struct timespec time);
> +time_t support_timespec_ns (struct timespec time);
OK.
>
> struct timespec support_timespec_normalize (struct timespec time);
>
> diff --git a/support/tst-timespec.c b/support/tst-timespec.c
> index 71423555a9..ac5ed228ba 100644
> --- a/support/tst-timespec.c
> +++ b/support/tst-timespec.c
> @@ -19,13 +19,14 @@
> #include <support/timespec.h>
> #include <support/check.h>
> #include <limits.h>
> +#include <intprops.h>
OK.
>
> #define TIMESPEC_HZ 1000000000
>
> struct timespec_ns_test_case
> {
> struct timespec time;
> - long time_ns;
> + time_t time_ns;
OK.
> };
>
> struct timespec_norm_test_case
> @@ -43,6 +44,9 @@ struct timespec_test_case
> int result;
> };
>
> +#define TIME_T_MIN TYPE_MINIMUM (time_t)
> +#define TIME_T_MAX TYPE_MAXIMUM (time_t)
OK.
> +
> /* Test cases for timespec_ns */
> struct timespec_ns_test_case ns_cases[] = {
> {.time = {.tv_sec = 0, .tv_nsec = 0},
> @@ -73,36 +77,42 @@ struct timespec_ns_test_case ns_cases[] = {
> .time_ns = -TIMESPEC_HZ + 1,
> },
> /* Overflow bondary by 2 */
> - {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ, .tv_nsec = LONG_MAX%TIMESPEC_HZ - 1},
> - .time_ns = LONG_MAX - 1,
> + {.time = {.tv_sec = TIME_T_MAX / TIMESPEC_HZ,
> + .tv_nsec = TIME_T_MAX % TIMESPEC_HZ - 1},
> + .time_ns = TIME_T_MAX - 1,
> },
> /* Overflow bondary */
> - {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ, .tv_nsec = LONG_MAX%TIMESPEC_HZ},
> - .time_ns = LONG_MAX,
> + {.time = {.tv_sec = TIME_T_MAX / TIMESPEC_HZ,
> + .tv_nsec = TIME_T_MAX % TIMESPEC_HZ},
> + .time_ns = TIME_T_MAX,
> },
> /* Underflow bondary by 1 */
> - {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ, .tv_nsec = LONG_MIN%TIMESPEC_HZ + 1},
> - .time_ns = LONG_MIN + 1,
> + {.time = {.tv_sec = TIME_T_MIN / TIMESPEC_HZ,
> + .tv_nsec = TIME_T_MIN % TIMESPEC_HZ + 1},
> + .time_ns = TIME_T_MIN + 1,
> },
> /* Underflow bondary */
> - {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ, .tv_nsec = LONG_MIN%TIMESPEC_HZ},
> - .time_ns = LONG_MIN,
> + {.time = {.tv_sec = TIME_T_MIN / TIMESPEC_HZ,
> + .tv_nsec = TIME_T_MIN % TIMESPEC_HZ},
> + .time_ns = TIME_T_MIN,
> },
> /* Multiplication overflow */
> - {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ + 1, .tv_nsec = 1},
> - .time_ns = LONG_MAX,
> + {.time = {.tv_sec = TIME_T_MAX / TIMESPEC_HZ + 1, .tv_nsec = 1},
> + .time_ns = TIME_T_MAX,
> },
> /* Multiplication underflow */
> - {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ - 1, .tv_nsec = -1},
> - .time_ns = LONG_MIN,
> + {.time = {.tv_sec = TIME_T_MIN / TIMESPEC_HZ - 1, .tv_nsec = -1},
> + .time_ns = TIME_T_MIN,
> },
> /* Sum overflows */
> - {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ, .tv_nsec = LONG_MAX%TIMESPEC_HZ + 1},
> - .time_ns = LONG_MAX,
> + {.time = {.tv_sec = TIME_T_MAX / TIMESPEC_HZ,
> + .tv_nsec = TIME_T_MAX % TIMESPEC_HZ + 1},
> + .time_ns = TIME_T_MAX,
> },
> /* Sum underflow */
> - {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ, .tv_nsec = LONG_MIN%TIMESPEC_HZ - 1},
> - .time_ns = LONG_MIN,
> + {.time = {.tv_sec = TIME_T_MIN / TIMESPEC_HZ,
> + .tv_nsec = TIME_T_MIN % TIMESPEC_HZ - 1},
> + .time_ns = TIME_T_MIN,
> }
> };
>
> @@ -144,28 +154,28 @@ struct timespec_norm_test_case norm_cases[] = {
> .norm = {.tv_sec = -2, .tv_nsec = -1}
> },
> /* Overflow bondary by 2 */
> - {.time = {.tv_sec = LONG_MAX - 2, .tv_nsec = TIMESPEC_HZ + 1},
> - .norm = {.tv_sec = LONG_MAX - 1, 1},
> + {.time = {.tv_sec = TIME_T_MAX - 2, .tv_nsec = TIMESPEC_HZ + 1},
> + .norm = {.tv_sec = TIME_T_MAX - 1, 1},
> },
> /* Overflow bondary by 1 */
> - {.time = {.tv_sec = LONG_MAX - 1, .tv_nsec = TIMESPEC_HZ + 1},
> - .norm = {.tv_sec = LONG_MAX, .tv_nsec = 1},
> + {.time = {.tv_sec = TIME_T_MAX - 1, .tv_nsec = TIMESPEC_HZ + 1},
> + .norm = {.tv_sec = TIME_T_MAX, .tv_nsec = 1},
> },
> /* Underflow bondary by 2 */
> - {.time = {.tv_sec = LONG_MIN + 2, .tv_nsec = -TIMESPEC_HZ - 1},
> - .norm = {.tv_sec = LONG_MIN + 1, -1},
> + {.time = {.tv_sec = TIME_T_MIN + 2, .tv_nsec = -TIMESPEC_HZ - 1},
> + .norm = {.tv_sec = TIME_T_MIN + 1, -1},
> },
> /* Underflow bondary by 1 */
> - {.time = {.tv_sec = LONG_MIN + 1, .tv_nsec = -TIMESPEC_HZ - 1},
> - .norm = {.tv_sec = LONG_MIN, .tv_nsec = -1},
> + {.time = {.tv_sec = TIME_T_MIN + 1, .tv_nsec = -TIMESPEC_HZ - 1},
> + .norm = {.tv_sec = TIME_T_MIN, .tv_nsec = -1},
> },
> /* SUM overflow */
> - {.time = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> - .norm = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ - 1},
> + {.time = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ},
> + .norm = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ - 1},
> },
> /* SUM underflow */
> - {.time = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> - .norm = {.tv_sec = LONG_MIN, .tv_nsec = -1 * (TIMESPEC_HZ - 1)},
> + {.time = {.tv_sec = TIME_T_MIN, .tv_nsec = -TIMESPEC_HZ},
> + .norm = {.tv_sec = TIME_T_MIN, .tv_nsec = -1 * (TIMESPEC_HZ - 1)},
> }
> };
>
> @@ -243,39 +253,41 @@ struct timespec_test_case check_cases[] = {
> },
> /* Maximum/Minimum long values */
> /* 14 */
> - {.expected = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ - 1},
> - .observed = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ - 2},
> + {.expected = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ - 1},
> + .observed = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ - 2},
> .upper_bound = 1, .lower_bound = .9, .result = 1,
> },
> /* 15 - support_timespec_ns overflow */
> - {.expected = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> - .observed = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> + {.expected = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ},
> + .observed = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ},
> .upper_bound = 1, .lower_bound = 1, .result = 1,
> },
> /* 16 - support_timespec_ns overflow + underflow */
> - {.expected = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> - .observed = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> + {.expected = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ},
> + .observed = {.tv_sec = TIME_T_MIN, .tv_nsec = -TIMESPEC_HZ},
> .upper_bound = 1, .lower_bound = 1, .result = 0,
> },
> /* 17 - support_timespec_ns underflow */
> - {.expected = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> - .observed = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> + {.expected = {.tv_sec = TIME_T_MIN, .tv_nsec = -TIMESPEC_HZ},
> + .observed = {.tv_sec = TIME_T_MIN, .tv_nsec = -TIMESPEC_HZ},
> .upper_bound = 1, .lower_bound = 1, .result = 1,
> },
> /* 18 - support_timespec_ns underflow + overflow */
> - {.expected = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> - .observed = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> + {.expected = {.tv_sec = TIME_T_MIN, .tv_nsec = -TIMESPEC_HZ},
> + .observed = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ},
> .upper_bound = 1, .lower_bound = 1, .result = 0,
> },
> /* 19 - Biggest division */
> - {.expected = {.tv_sec = LONG_MAX / TIMESPEC_HZ , .tv_nsec = TIMESPEC_HZ - 1},
> + {.expected = {.tv_sec = TIME_T_MAX / TIMESPEC_HZ,
> + .tv_nsec = TIMESPEC_HZ - 1},
> .observed = {.tv_sec = 0, .tv_nsec = 1},
> .upper_bound = 1, .lower_bound = 1.0842021724855044e-19, .result = 1,
> },
> /* 20 - Lowest division */
> {.expected = {.tv_sec = 0, .tv_nsec = 1},
> - .observed = {.tv_sec = LONG_MAX / TIMESPEC_HZ , .tv_nsec = TIMESPEC_HZ - 1},
> - .upper_bound = LONG_MAX, .lower_bound = 1, .result = 1,
> + .observed = {.tv_sec = TIME_T_MAX / TIMESPEC_HZ,
> + .tv_nsec = TIMESPEC_HZ - 1},
> + .upper_bound = TIME_T_MAX, .lower_bound = 1, .result = 1,
OK.
> },
> };
>
> @@ -288,6 +300,7 @@ do_test (void)
> printf("Testing support_timespec_ns\n");
> for (i = 0; i < ntests; i++)
> {
> + printf("Test case %d\n", i);
OK.
> TEST_COMPARE (support_timespec_ns (ns_cases[i].time),
> ns_cases[i].time_ns);
> }
> @@ -297,6 +310,7 @@ do_test (void)
> printf("Testing support_timespec_normalize\n");
> for (i = 0; i < ntests; i++)
> {
> + printf("Test case %d\n", i);
OK.
> result = support_timespec_normalize (norm_cases[i].time);
> TEST_COMPARE (norm_cases[i].norm.tv_sec, result.tv_sec);
> TEST_COMPARE (norm_cases[i].norm.tv_nsec, result.tv_nsec);
> --
> 2.26.2
>
--
Cheers,
Carlos.
^ permalink raw reply [flat|nested] 44+ messages in thread* Re: [PATCH] Correct timespec implementation [BZ #26232]
2020-07-13 23:30 ` [PATCH] Correct timespec implementation [BZ #26232] H.J. Lu via Libc-alpha
2020-07-14 2:35 ` Carlos O'Donell via Libc-alpha
@ 2020-07-14 11:16 ` Florian Weimer via Libc-alpha
2020-07-14 11:42 ` H.J. Lu via Libc-alpha
1 sibling, 1 reply; 44+ messages in thread
From: Florian Weimer via Libc-alpha @ 2020-07-14 11:16 UTC (permalink / raw)
To: H.J. Lu via Libc-alpha
* H. J. Lu via Libc-alpha:
> -/* Convert TIME to nanoseconds stored in a long.
> - Returns long maximum or minimum if the conversion overflows
> +/* Convert TIME to nanoseconds stored in a time_t.
> + Returns time_t maximum or minimum if the conversion overflows
> or underflows, respectively. */
> -long
> +time_t
> support_timespec_ns (struct timespec time)
> {
Why not use long long int as the type?
Thanks,
Florian
^ permalink raw reply [flat|nested] 44+ messages in thread* Re: [PATCH] Correct timespec implementation [BZ #26232]
2020-07-14 11:16 ` Florian Weimer via Libc-alpha
@ 2020-07-14 11:42 ` H.J. Lu via Libc-alpha
2020-07-14 12:04 ` H.J. Lu via Libc-alpha
2020-07-14 13:08 ` Lucas A. M. Magalhaes via Libc-alpha
0 siblings, 2 replies; 44+ messages in thread
From: H.J. Lu via Libc-alpha @ 2020-07-14 11:42 UTC (permalink / raw)
To: Florian Weimer; +Cc: H.J. Lu via Libc-alpha
[-- Attachment #1: Type: text/plain, Size: 686 bytes --]
On Tue, Jul 14, 2020 at 4:16 AM Florian Weimer <fweimer@redhat.com> wrote:
>
> * H. J. Lu via Libc-alpha:
>
> > -/* Convert TIME to nanoseconds stored in a long.
> > - Returns long maximum or minimum if the conversion overflows
> > +/* Convert TIME to nanoseconds stored in a time_t.
> > + Returns time_t maximum or minimum if the conversion overflows
> > or underflows, respectively. */
> > -long
> > +time_t
> > support_timespec_ns (struct timespec time)
> > {
>
> Why not use long long int as the type?
>
Using time_t has the least impact since most of the targets have time_t == long.
I am checking in this patch and will post a followup patch with long long.
--
H.J.
[-- Attachment #2: 0001-Correct-timespec-implementation-BZ-26232.patch --]
[-- Type: text/x-patch, Size: 11687 bytes --]
From 67ff24ce5b9b294089776563d656ee7678c6d076 Mon Sep 17 00:00:00 2001
From: "H.J. Lu" <hjl.tools@gmail.com>
Date: Mon, 13 Jul 2020 16:15:56 -0700
Subject: [PATCH] Correct timespec implementation [BZ #26232]
commit 04deeaa9ea74b0679dfc9d9155a37b6425f19a9f
Author: Lucas A. M. Magalhaes <lamm@linux.ibm.com>
Date: Fri Jul 10 19:41:06 2020 -0300
Fix time/tst-cpuclock1 intermitent failures
has 2 issues:
1. It assumes time_t == long which is false on x32.
2. tst-timespec.c is compiled without -fexcess-precision=standard which
generates incorrect results on i686 in support_timespec_check_in_range:
double ratio = (double)observed_norm / expected_norm;
return (lower_bound <= ratio && ratio <= upper_bound);
This patch does
1. Compile tst-timespec.c with -fexcess-precision=standard.
2. Replace long with time_t.
3. Replace LONG_MIN and LONG_MAX with TYPE_MINIMUM (time_t) and
TYPE_MAXIMUM (time_t).
---
support/Makefile | 7 +++
support/timespec.c | 18 +++-----
support/timespec.h | 2 +-
support/tst-timespec.c | 98 ++++++++++++++++++++++++------------------
4 files changed, 71 insertions(+), 54 deletions(-)
diff --git a/support/Makefile b/support/Makefile
index e74e0dd519..93faafddf9 100644
--- a/support/Makefile
+++ b/support/Makefile
@@ -196,6 +196,13 @@ CFLAGS-support_paths.c = \
-DROOTSBINDIR_PATH=\"$(rootsbindir)\" \
-DCOMPLOCALEDIR_PATH=\"$(complocaledir)\"
+# In support_timespec_check_in_range we may be passed a very tight
+# range for which we should produce a correct result for expected
+# being withing the observed range. The code uses double internally
+# in support_timespec_check_in_range and for that computation we use
+# -fexcess-precision=standard.
+CFLAGS-timespec.c += -fexcess-precision=standard
+
ifeq (,$(CXX))
LINKS_DSO_PROGRAM = links-dso-program-c
else
diff --git a/support/timespec.c b/support/timespec.c
index 9f5449e49e..edbdb165ec 100644
--- a/support/timespec.c
+++ b/support/timespec.c
@@ -60,21 +60,17 @@ test_timespec_equal_or_after_impl (const char *file, int line,
}
}
-/* Convert TIME to nanoseconds stored in a long.
- Returns long maximum or minimum if the conversion overflows
+/* Convert TIME to nanoseconds stored in a time_t.
+ Returns time_t maximum or minimum if the conversion overflows
or underflows, respectively. */
-long
+time_t
support_timespec_ns (struct timespec time)
{
- long time_ns;
+ time_t time_ns;
if (INT_MULTIPLY_WRAPV(time.tv_sec, TIMESPEC_HZ, &time_ns))
- {
- return (time.tv_sec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long);
- }
+ return time.tv_sec < 0 ? TYPE_MINIMUM(time_t) : TYPE_MAXIMUM(time_t);
if (INT_ADD_WRAPV(time_ns, time.tv_nsec, &time_ns))
- {
- return (time.tv_nsec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long);
- }
+ return time.tv_nsec < 0 ? TYPE_MINIMUM(time_t) : TYPE_MAXIMUM(time_t);
return time_ns;
}
@@ -113,7 +109,7 @@ support_timespec_check_in_range (struct timespec expected, struct timespec obser
double lower_bound, double upper_bound)
{
assert (upper_bound >= lower_bound);
- long expected_norm, observed_norm;
+ time_t expected_norm, observed_norm;
expected_norm = support_timespec_ns (expected);
/* Don't divide by zero */
assert(expected_norm != 0);
diff --git a/support/timespec.h b/support/timespec.h
index fd5466745d..1a6775a882 100644
--- a/support/timespec.h
+++ b/support/timespec.h
@@ -48,7 +48,7 @@ void test_timespec_equal_or_after_impl (const char *file, int line,
const struct timespec left,
const struct timespec right);
-long support_timespec_ns (struct timespec time);
+time_t support_timespec_ns (struct timespec time);
struct timespec support_timespec_normalize (struct timespec time);
diff --git a/support/tst-timespec.c b/support/tst-timespec.c
index 71423555a9..ac5ed228ba 100644
--- a/support/tst-timespec.c
+++ b/support/tst-timespec.c
@@ -19,13 +19,14 @@
#include <support/timespec.h>
#include <support/check.h>
#include <limits.h>
+#include <intprops.h>
#define TIMESPEC_HZ 1000000000
struct timespec_ns_test_case
{
struct timespec time;
- long time_ns;
+ time_t time_ns;
};
struct timespec_norm_test_case
@@ -43,6 +44,9 @@ struct timespec_test_case
int result;
};
+#define TIME_T_MIN TYPE_MINIMUM (time_t)
+#define TIME_T_MAX TYPE_MAXIMUM (time_t)
+
/* Test cases for timespec_ns */
struct timespec_ns_test_case ns_cases[] = {
{.time = {.tv_sec = 0, .tv_nsec = 0},
@@ -73,36 +77,42 @@ struct timespec_ns_test_case ns_cases[] = {
.time_ns = -TIMESPEC_HZ + 1,
},
/* Overflow bondary by 2 */
- {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ, .tv_nsec = LONG_MAX%TIMESPEC_HZ - 1},
- .time_ns = LONG_MAX - 1,
+ {.time = {.tv_sec = TIME_T_MAX / TIMESPEC_HZ,
+ .tv_nsec = TIME_T_MAX % TIMESPEC_HZ - 1},
+ .time_ns = TIME_T_MAX - 1,
},
/* Overflow bondary */
- {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ, .tv_nsec = LONG_MAX%TIMESPEC_HZ},
- .time_ns = LONG_MAX,
+ {.time = {.tv_sec = TIME_T_MAX / TIMESPEC_HZ,
+ .tv_nsec = TIME_T_MAX % TIMESPEC_HZ},
+ .time_ns = TIME_T_MAX,
},
/* Underflow bondary by 1 */
- {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ, .tv_nsec = LONG_MIN%TIMESPEC_HZ + 1},
- .time_ns = LONG_MIN + 1,
+ {.time = {.tv_sec = TIME_T_MIN / TIMESPEC_HZ,
+ .tv_nsec = TIME_T_MIN % TIMESPEC_HZ + 1},
+ .time_ns = TIME_T_MIN + 1,
},
/* Underflow bondary */
- {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ, .tv_nsec = LONG_MIN%TIMESPEC_HZ},
- .time_ns = LONG_MIN,
+ {.time = {.tv_sec = TIME_T_MIN / TIMESPEC_HZ,
+ .tv_nsec = TIME_T_MIN % TIMESPEC_HZ},
+ .time_ns = TIME_T_MIN,
},
/* Multiplication overflow */
- {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ + 1, .tv_nsec = 1},
- .time_ns = LONG_MAX,
+ {.time = {.tv_sec = TIME_T_MAX / TIMESPEC_HZ + 1, .tv_nsec = 1},
+ .time_ns = TIME_T_MAX,
},
/* Multiplication underflow */
- {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ - 1, .tv_nsec = -1},
- .time_ns = LONG_MIN,
+ {.time = {.tv_sec = TIME_T_MIN / TIMESPEC_HZ - 1, .tv_nsec = -1},
+ .time_ns = TIME_T_MIN,
},
/* Sum overflows */
- {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ, .tv_nsec = LONG_MAX%TIMESPEC_HZ + 1},
- .time_ns = LONG_MAX,
+ {.time = {.tv_sec = TIME_T_MAX / TIMESPEC_HZ,
+ .tv_nsec = TIME_T_MAX % TIMESPEC_HZ + 1},
+ .time_ns = TIME_T_MAX,
},
/* Sum underflow */
- {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ, .tv_nsec = LONG_MIN%TIMESPEC_HZ - 1},
- .time_ns = LONG_MIN,
+ {.time = {.tv_sec = TIME_T_MIN / TIMESPEC_HZ,
+ .tv_nsec = TIME_T_MIN % TIMESPEC_HZ - 1},
+ .time_ns = TIME_T_MIN,
}
};
@@ -144,28 +154,28 @@ struct timespec_norm_test_case norm_cases[] = {
.norm = {.tv_sec = -2, .tv_nsec = -1}
},
/* Overflow bondary by 2 */
- {.time = {.tv_sec = LONG_MAX - 2, .tv_nsec = TIMESPEC_HZ + 1},
- .norm = {.tv_sec = LONG_MAX - 1, 1},
+ {.time = {.tv_sec = TIME_T_MAX - 2, .tv_nsec = TIMESPEC_HZ + 1},
+ .norm = {.tv_sec = TIME_T_MAX - 1, 1},
},
/* Overflow bondary by 1 */
- {.time = {.tv_sec = LONG_MAX - 1, .tv_nsec = TIMESPEC_HZ + 1},
- .norm = {.tv_sec = LONG_MAX, .tv_nsec = 1},
+ {.time = {.tv_sec = TIME_T_MAX - 1, .tv_nsec = TIMESPEC_HZ + 1},
+ .norm = {.tv_sec = TIME_T_MAX, .tv_nsec = 1},
},
/* Underflow bondary by 2 */
- {.time = {.tv_sec = LONG_MIN + 2, .tv_nsec = -TIMESPEC_HZ - 1},
- .norm = {.tv_sec = LONG_MIN + 1, -1},
+ {.time = {.tv_sec = TIME_T_MIN + 2, .tv_nsec = -TIMESPEC_HZ - 1},
+ .norm = {.tv_sec = TIME_T_MIN + 1, -1},
},
/* Underflow bondary by 1 */
- {.time = {.tv_sec = LONG_MIN + 1, .tv_nsec = -TIMESPEC_HZ - 1},
- .norm = {.tv_sec = LONG_MIN, .tv_nsec = -1},
+ {.time = {.tv_sec = TIME_T_MIN + 1, .tv_nsec = -TIMESPEC_HZ - 1},
+ .norm = {.tv_sec = TIME_T_MIN, .tv_nsec = -1},
},
/* SUM overflow */
- {.time = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
- .norm = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ - 1},
+ {.time = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ},
+ .norm = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ - 1},
},
/* SUM underflow */
- {.time = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
- .norm = {.tv_sec = LONG_MIN, .tv_nsec = -1 * (TIMESPEC_HZ - 1)},
+ {.time = {.tv_sec = TIME_T_MIN, .tv_nsec = -TIMESPEC_HZ},
+ .norm = {.tv_sec = TIME_T_MIN, .tv_nsec = -1 * (TIMESPEC_HZ - 1)},
}
};
@@ -243,39 +253,41 @@ struct timespec_test_case check_cases[] = {
},
/* Maximum/Minimum long values */
/* 14 */
- {.expected = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ - 1},
- .observed = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ - 2},
+ {.expected = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ - 1},
+ .observed = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ - 2},
.upper_bound = 1, .lower_bound = .9, .result = 1,
},
/* 15 - support_timespec_ns overflow */
- {.expected = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
- .observed = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
+ {.expected = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ},
+ .observed = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ},
.upper_bound = 1, .lower_bound = 1, .result = 1,
},
/* 16 - support_timespec_ns overflow + underflow */
- {.expected = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
- .observed = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
+ {.expected = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ},
+ .observed = {.tv_sec = TIME_T_MIN, .tv_nsec = -TIMESPEC_HZ},
.upper_bound = 1, .lower_bound = 1, .result = 0,
},
/* 17 - support_timespec_ns underflow */
- {.expected = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
- .observed = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
+ {.expected = {.tv_sec = TIME_T_MIN, .tv_nsec = -TIMESPEC_HZ},
+ .observed = {.tv_sec = TIME_T_MIN, .tv_nsec = -TIMESPEC_HZ},
.upper_bound = 1, .lower_bound = 1, .result = 1,
},
/* 18 - support_timespec_ns underflow + overflow */
- {.expected = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
- .observed = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
+ {.expected = {.tv_sec = TIME_T_MIN, .tv_nsec = -TIMESPEC_HZ},
+ .observed = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ},
.upper_bound = 1, .lower_bound = 1, .result = 0,
},
/* 19 - Biggest division */
- {.expected = {.tv_sec = LONG_MAX / TIMESPEC_HZ , .tv_nsec = TIMESPEC_HZ - 1},
+ {.expected = {.tv_sec = TIME_T_MAX / TIMESPEC_HZ,
+ .tv_nsec = TIMESPEC_HZ - 1},
.observed = {.tv_sec = 0, .tv_nsec = 1},
.upper_bound = 1, .lower_bound = 1.0842021724855044e-19, .result = 1,
},
/* 20 - Lowest division */
{.expected = {.tv_sec = 0, .tv_nsec = 1},
- .observed = {.tv_sec = LONG_MAX / TIMESPEC_HZ , .tv_nsec = TIMESPEC_HZ - 1},
- .upper_bound = LONG_MAX, .lower_bound = 1, .result = 1,
+ .observed = {.tv_sec = TIME_T_MAX / TIMESPEC_HZ,
+ .tv_nsec = TIMESPEC_HZ - 1},
+ .upper_bound = TIME_T_MAX, .lower_bound = 1, .result = 1,
},
};
@@ -288,6 +300,7 @@ do_test (void)
printf("Testing support_timespec_ns\n");
for (i = 0; i < ntests; i++)
{
+ printf("Test case %d\n", i);
TEST_COMPARE (support_timespec_ns (ns_cases[i].time),
ns_cases[i].time_ns);
}
@@ -297,6 +310,7 @@ do_test (void)
printf("Testing support_timespec_normalize\n");
for (i = 0; i < ntests; i++)
{
+ printf("Test case %d\n", i);
result = support_timespec_normalize (norm_cases[i].time);
TEST_COMPARE (norm_cases[i].norm.tv_sec, result.tv_sec);
TEST_COMPARE (norm_cases[i].norm.tv_nsec, result.tv_nsec);
--
2.26.2
^ permalink raw reply related [flat|nested] 44+ messages in thread* Re: [PATCH] Correct timespec implementation [BZ #26232]
2020-07-14 11:42 ` H.J. Lu via Libc-alpha
@ 2020-07-14 12:04 ` H.J. Lu via Libc-alpha
2020-07-14 12:18 ` Florian Weimer via Libc-alpha
2020-07-14 13:08 ` Lucas A. M. Magalhaes via Libc-alpha
1 sibling, 1 reply; 44+ messages in thread
From: H.J. Lu via Libc-alpha @ 2020-07-14 12:04 UTC (permalink / raw)
To: Florian Weimer; +Cc: H.J. Lu via Libc-alpha
On Tue, Jul 14, 2020 at 4:42 AM H.J. Lu <hjl.tools@gmail.com> wrote:
>
> On Tue, Jul 14, 2020 at 4:16 AM Florian Weimer <fweimer@redhat.com> wrote:
> >
> > * H. J. Lu via Libc-alpha:
> >
> > > -/* Convert TIME to nanoseconds stored in a long.
> > > - Returns long maximum or minimum if the conversion overflows
> > > +/* Convert TIME to nanoseconds stored in a time_t.
> > > + Returns time_t maximum or minimum if the conversion overflows
> > > or underflows, respectively. */
> > > -long
> > > +time_t
> > > support_timespec_ns (struct timespec time)
> > > {
> >
> > Why not use long long int as the type?
> >
>
> Using time_t has the least impact since most of the targets have time_t == long.
> I am checking in this patch and will post a followup patch with long long.
>
There are
time_t
support_timespec_ns (struct timespec time)
{
time_t time_ns;
if (INT_MULTIPLY_WRAPV(time.tv_sec, TIMESPEC_HZ, &time_ns))
return time.tv_sec < 0 ? TYPE_MINIMUM(time_t) : TYPE_MAXIMUM(time_t);
if (INT_ADD_WRAPV(time_ns, time.tv_nsec, &time_ns))
return time.tv_nsec < 0 ? TYPE_MINIMUM(time_t) : TYPE_MAXIMUM(time_t);
return time_ns;
}
Even if support_timespec_ns is changed to return long long, we still may need to
keep
time_t time_ns;
for
if (INT_MULTIPLY_WRAPV(time.tv_sec, TIMESPEC_HZ, &time_ns))
and
if (INT_ADD_WRAPV(time_ns, time.tv_nsec, &time_ns))
It looks odd to return long long here.
--
H.J.
^ permalink raw reply [flat|nested] 44+ messages in thread* Re: [PATCH] Correct timespec implementation [BZ #26232]
2020-07-14 12:04 ` H.J. Lu via Libc-alpha
@ 2020-07-14 12:18 ` Florian Weimer via Libc-alpha
2020-07-14 13:12 ` H.J. Lu via Libc-alpha
0 siblings, 1 reply; 44+ messages in thread
From: Florian Weimer via Libc-alpha @ 2020-07-14 12:18 UTC (permalink / raw)
To: H.J. Lu; +Cc: H.J. Lu via Libc-alpha
* H. J. Lu:
> There are
>
> time_t
> support_timespec_ns (struct timespec time)
> {
> time_t time_ns;
> if (INT_MULTIPLY_WRAPV(time.tv_sec, TIMESPEC_HZ, &time_ns))
> return time.tv_sec < 0 ? TYPE_MINIMUM(time_t) : TYPE_MAXIMUM(time_t);
> if (INT_ADD_WRAPV(time_ns, time.tv_nsec, &time_ns))
> return time.tv_nsec < 0 ? TYPE_MINIMUM(time_t) : TYPE_MAXIMUM(time_t);
> return time_ns;
> }
>
> Even if support_timespec_ns is changed to return long long, we still
> may need to keep
>
> time_t time_ns;
>
> for
>
> if (INT_MULTIPLY_WRAPV(time.tv_sec, TIMESPEC_HZ, &time_ns))
>
> and
>
> if (INT_ADD_WRAPV(time_ns, time.tv_nsec, &time_ns))
>
> It looks odd to return long long here.
Why?
You can use the GCC built-ins for checked arithmetic, they support mixed
types.
Thanks,
Florian
^ permalink raw reply [flat|nested] 44+ messages in thread* Re: [PATCH] Correct timespec implementation [BZ #26232]
2020-07-14 12:18 ` Florian Weimer via Libc-alpha
@ 2020-07-14 13:12 ` H.J. Lu via Libc-alpha
2020-07-14 13:14 ` Florian Weimer via Libc-alpha
0 siblings, 1 reply; 44+ messages in thread
From: H.J. Lu via Libc-alpha @ 2020-07-14 13:12 UTC (permalink / raw)
To: Florian Weimer; +Cc: H.J. Lu via Libc-alpha
On Tue, Jul 14, 2020 at 5:18 AM Florian Weimer <fweimer@redhat.com> wrote:
>
> * H. J. Lu:
>
> > There are
> >
> > time_t
> > support_timespec_ns (struct timespec time)
> > {
> > time_t time_ns;
> > if (INT_MULTIPLY_WRAPV(time.tv_sec, TIMESPEC_HZ, &time_ns))
> > return time.tv_sec < 0 ? TYPE_MINIMUM(time_t) : TYPE_MAXIMUM(time_t);
> > if (INT_ADD_WRAPV(time_ns, time.tv_nsec, &time_ns))
> > return time.tv_nsec < 0 ? TYPE_MINIMUM(time_t) : TYPE_MAXIMUM(time_t);
> > return time_ns;
> > }
> >
> > Even if support_timespec_ns is changed to return long long, we still
> > may need to keep
> >
> > time_t time_ns;
> >
> > for
> >
> > if (INT_MULTIPLY_WRAPV(time.tv_sec, TIMESPEC_HZ, &time_ns))
> >
> > and
> >
> > if (INT_ADD_WRAPV(time_ns, time.tv_nsec, &time_ns))
> >
> > It looks odd to return long long here.
>
> Why?
>
> You can use the GCC built-ins for checked arithmetic, they support mixed
> types.
>
This doesn't work on i686:
diff --git a/support/timespec.c b/support/timespec.c
index edbdb165ec..c35e8a8201 100644
--- a/support/timespec.c
+++ b/support/timespec.c
@@ -63,10 +63,10 @@ test_timespec_equal_or_after_impl (const char
*file, int line,
/* Convert TIME to nanoseconds stored in a time_t.
Returns time_t maximum or minimum if the conversion overflows
or underflows, respectively. */
-time_t
+long long
support_timespec_ns (struct timespec time)
{
- time_t time_ns;
+ long long time_ns;
if (INT_MULTIPLY_WRAPV(time.tv_sec, TIMESPEC_HZ, &time_ns))
return time.tv_sec < 0 ? TYPE_MINIMUM(time_t) : TYPE_MAXIMUM(time_t);
if (INT_ADD_WRAPV(time_ns, time.tv_nsec, &time_ns))
diff --git a/support/timespec.h b/support/timespec.h
index 1a6775a882..68055f42c3 100644
--- a/support/timespec.h
+++ b/support/timespec.h
@@ -48,7 +48,7 @@ void test_timespec_equal_or_after_impl (const char
*file, int line,
const struct timespec left,
const struct timespec right);
-time_t support_timespec_ns (struct timespec time);
+long long support_timespec_ns (struct timespec time);
struct timespec support_timespec_normalize (struct timespec time);
This works:
diff --git a/support/timespec.c b/support/timespec.c
index edbdb165ec..b117e7c0d2 100644
--- a/support/timespec.c
+++ b/support/timespec.c
@@ -63,7 +63,7 @@ test_timespec_equal_or_after_impl (const char *file, int line,
/* Convert TIME to nanoseconds stored in a time_t.
Returns time_t maximum or minimum if the conversion overflows
or underflows, respectively. */
-time_t
+long long
support_timespec_ns (struct timespec time)
{
time_t time_ns;
diff --git a/support/timespec.h b/support/timespec.h
index 1a6775a882..68055f42c3 100644
--- a/support/timespec.h
+++ b/support/timespec.h
@@ -48,7 +48,7 @@ void test_timespec_equal_or_after_impl (const char
*file, int line,
const struct timespec left,
const struct timespec right);
-time_t support_timespec_ns (struct timespec time);
+long long support_timespec_ns (struct timespec time);
struct timespec support_timespec_normalize (struct timespec time);
What is the advantage of long long over time_t?
--
H.J.
^ permalink raw reply related [flat|nested] 44+ messages in thread* Re: [PATCH] Correct timespec implementation [BZ #26232]
2020-07-14 13:12 ` H.J. Lu via Libc-alpha
@ 2020-07-14 13:14 ` Florian Weimer via Libc-alpha
2020-07-14 13:17 ` H.J. Lu via Libc-alpha
0 siblings, 1 reply; 44+ messages in thread
From: Florian Weimer via Libc-alpha @ 2020-07-14 13:14 UTC (permalink / raw)
To: H.J. Lu; +Cc: H.J. Lu via Libc-alpha
* H. J. Lu:
> diff --git a/support/timespec.c b/support/timespec.c
> index edbdb165ec..c35e8a8201 100644
> --- a/support/timespec.c
> +++ b/support/timespec.c
> @@ -63,10 +63,10 @@ test_timespec_equal_or_after_impl (const char
> *file, int line,
> /* Convert TIME to nanoseconds stored in a time_t.
> Returns time_t maximum or minimum if the conversion overflows
> or underflows, respectively. */
> -time_t
> +long long
> support_timespec_ns (struct timespec time)
> {
> - time_t time_ns;
> + long long time_ns;
> if (INT_MULTIPLY_WRAPV(time.tv_sec, TIMESPEC_HZ, &time_ns))
> return time.tv_sec < 0 ? TYPE_MINIMUM(time_t) : TYPE_MAXIMUM(time_t);
> if (INT_ADD_WRAPV(time_ns, time.tv_nsec, &time_ns))
I suspect you need to use LONG_LONG_MIN and LONG_LONG_MAX here.
Thanks,
Florian
^ permalink raw reply [flat|nested] 44+ messages in thread* Re: [PATCH] Correct timespec implementation [BZ #26232]
2020-07-14 13:14 ` Florian Weimer via Libc-alpha
@ 2020-07-14 13:17 ` H.J. Lu via Libc-alpha
2020-07-15 19:38 ` Paul Eggert
0 siblings, 1 reply; 44+ messages in thread
From: H.J. Lu via Libc-alpha @ 2020-07-14 13:17 UTC (permalink / raw)
To: Florian Weimer; +Cc: H.J. Lu via Libc-alpha
On Tue, Jul 14, 2020 at 6:15 AM Florian Weimer <fweimer@redhat.com> wrote:
>
> * H. J. Lu:
>
> > diff --git a/support/timespec.c b/support/timespec.c
> > index edbdb165ec..c35e8a8201 100644
> > --- a/support/timespec.c
> > +++ b/support/timespec.c
> > @@ -63,10 +63,10 @@ test_timespec_equal_or_after_impl (const char
> > *file, int line,
> > /* Convert TIME to nanoseconds stored in a time_t.
> > Returns time_t maximum or minimum if the conversion overflows
> > or underflows, respectively. */
> > -time_t
> > +long long
> > support_timespec_ns (struct timespec time)
> > {
> > - time_t time_ns;
> > + long long time_ns;
> > if (INT_MULTIPLY_WRAPV(time.tv_sec, TIMESPEC_HZ, &time_ns))
> > return time.tv_sec < 0 ? TYPE_MINIMUM(time_t) : TYPE_MAXIMUM(time_t);
> > if (INT_ADD_WRAPV(time_ns, time.tv_nsec, &time_ns))
>
> I suspect you need to use LONG_LONG_MIN and LONG_LONG_MAX here.
>
No, it doesn't work on i686.
--
H.J.
^ permalink raw reply [flat|nested] 44+ messages in thread* Re: [PATCH] Correct timespec implementation [BZ #26232]
2020-07-14 13:17 ` H.J. Lu via Libc-alpha
@ 2020-07-15 19:38 ` Paul Eggert
2020-07-15 19:44 ` H.J. Lu via Libc-alpha
0 siblings, 1 reply; 44+ messages in thread
From: Paul Eggert @ 2020-07-15 19:38 UTC (permalink / raw)
To: H.J. Lu, Florian Weimer; +Cc: H.J. Lu via Libc-alpha
On 7/14/20 6:17 AM, H.J. Lu via Libc-alpha wrote:
> No, it doesn't work on i686.
Could you give more details about why it doesn't work? Is it a GCC bug (and if
so, which version and what flags did you use)? Is it a bug in
INT_MULTIPLY_WRAPV? in INT_ADD_WRAPV? What code is generated and why is it
wrong? That sort of thing. If there's a bug in INT_*_WRAPV I'd like to fix it.
An advantage to using 'long long' over 'time_t' is that insulates the code from
possible future changes where time_t is unsigned (which POSIX allows).
Admittedly this is unlikely.
^ permalink raw reply [flat|nested] 44+ messages in thread
* Re: [PATCH] Correct timespec implementation [BZ #26232]
2020-07-15 19:38 ` Paul Eggert
@ 2020-07-15 19:44 ` H.J. Lu via Libc-alpha
0 siblings, 0 replies; 44+ messages in thread
From: H.J. Lu via Libc-alpha @ 2020-07-15 19:44 UTC (permalink / raw)
To: Paul Eggert; +Cc: Florian Weimer, H.J. Lu via Libc-alpha
On Wed, Jul 15, 2020 at 12:38 PM Paul Eggert <eggert@cs.ucla.edu> wrote:
>
> On 7/14/20 6:17 AM, H.J. Lu via Libc-alpha wrote:
> > No, it doesn't work on i686.
>
> Could you give more details about why it doesn't work? Is it a GCC bug (and if
> so, which version and what flags did you use)? Is it a bug in
> INT_MULTIPLY_WRAPV? in INT_ADD_WRAPV? What code is generated and why is it
> wrong? That sort of thing. If there's a bug in INT_*_WRAPV I'd like to fix it.
Test failed on i686. Ping me in a couple weeks when I have some spare cycles.
> An advantage to using 'long long' over 'time_t' is that insulates the code from
> possible future changes where time_t is unsigned (which POSIX allows).
> Admittedly this is unlikely.
--
H.J.
^ permalink raw reply [flat|nested] 44+ messages in thread
* Re: [PATCH] Correct timespec implementation [BZ #26232]
2020-07-14 11:42 ` H.J. Lu via Libc-alpha
2020-07-14 12:04 ` H.J. Lu via Libc-alpha
@ 2020-07-14 13:08 ` Lucas A. M. Magalhaes via Libc-alpha
1 sibling, 0 replies; 44+ messages in thread
From: Lucas A. M. Magalhaes via Libc-alpha @ 2020-07-14 13:08 UTC (permalink / raw)
To: Florian Weimer, H.J. Lu, H.J. Lu via Libc-alpha; +Cc: H.J. Lu via Libc-alpha
Hi H.J. Lu,
Thanks for working on this. Overall the patch seams right to me. Just
one comment on style down there.
> From 67ff24ce5b9b294089776563d656ee7678c6d076 Mon Sep 17 00:00:00 2001
> From: "H.J. Lu" <hjl.tools@gmail.com>
> Date: Mon, 13 Jul 2020 16:15:56 -0700
> Subject: [PATCH] Correct timespec implementation [BZ #26232]
>
> commit 04deeaa9ea74b0679dfc9d9155a37b6425f19a9f
> Author: Lucas A. M. Magalhaes <lamm@linux.ibm.com>
> Date: Fri Jul 10 19:41:06 2020 -0300
>
> Fix time/tst-cpuclock1 intermitent failures
>
> has 2 issues:
>
> 1. It assumes time_t == long which is false on x32.
> 2. tst-timespec.c is compiled without -fexcess-precision=standard which
> generates incorrect results on i686 in support_timespec_check_in_range:
>
> double ratio = (double)observed_norm / expected_norm;
> return (lower_bound <= ratio && ratio <= upper_bound);
>
> This patch does
>
> 1. Compile tst-timespec.c with -fexcess-precision=standard.
> 2. Replace long with time_t.
> 3. Replace LONG_MIN and LONG_MAX with TYPE_MINIMUM (time_t) and
> TYPE_MAXIMUM (time_t).
> ---
> support/Makefile | 7 +++
> support/timespec.c | 18 +++-----
> support/timespec.h | 2 +-
> support/tst-timespec.c | 98 ++++++++++++++++++++++++------------------
> 4 files changed, 71 insertions(+), 54 deletions(-)
>
> diff --git a/support/Makefile b/support/Makefile
> index e74e0dd519..93faafddf9 100644
> --- a/support/Makefile
> +++ b/support/Makefile
> @@ -196,6 +196,13 @@ CFLAGS-support_paths.c = \
> -DROOTSBINDIR_PATH=\"$(rootsbindir)\" \
> -DCOMPLOCALEDIR_PATH=\"$(complocaledir)\"
>
> +# In support_timespec_check_in_range we may be passed a very tight
> +# range for which we should produce a correct result for expected
> +# being withing the observed range. The code uses double internally
> +# in support_timespec_check_in_range and for that computation we use
> +# -fexcess-precision=standard.
> +CFLAGS-timespec.c += -fexcess-precision=standard
> +
OK.
> ifeq (,$(CXX))
> LINKS_DSO_PROGRAM = links-dso-program-c
> else
> diff --git a/support/timespec.c b/support/timespec.c
> index 9f5449e49e..edbdb165ec 100644
> --- a/support/timespec.c
> +++ b/support/timespec.c
> @@ -60,21 +60,17 @@ test_timespec_equal_or_after_impl (const char *file, int line,
> }
> }
>
> -/* Convert TIME to nanoseconds stored in a long.
> - Returns long maximum or minimum if the conversion overflows
> +/* Convert TIME to nanoseconds stored in a time_t.
> + Returns time_t maximum or minimum if the conversion overflows
> or underflows, respectively. */
> -long
> +time_t
Ok.
> support_timespec_ns (struct timespec time)
> . {
> - long time_ns;
> + time_t time_ns;
> if (INT_MULTIPLY_WRAPV(time.tv_sec, TIMESPEC_HZ, &time_ns))
> - {
> - return (time.tv_sec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long);
> - }
> + return time.tv_sec < 0 ? TYPE_MINIMUM(time_t) : TYPE_MAXIMUM(time_t);
> if (INT_ADD_WRAPV(time_ns, time.tv_nsec, &time_ns))
> - {
> - return (time.tv_nsec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long);
> - }
> + return time.tv_nsec < 0 ? TYPE_MINIMUM(time_t) : TYPE_MAXIMUM(time_t);
> return time_ns;
> }
>
Ok.
> @@ -113,7 +109,7 @@ support_timespec_check_in_range (struct timespec expected, struct timespec obser
> double lower_bound, double upper_bound)
> {
> assert (upper_bound >= lower_bound);
> - long expected_norm, observed_norm;
> + time_t expected_norm, observed_norm;
> expected_norm = support_timespec_ns (expected);
> /* Don't divide by zero */
> assert(expected_norm != 0);
Ok.
> diff --git a/support/timespec.h b/support/timespec.h
> index fd5466745d..1a6775a882 100644
> --- a/support/timespec.h
> +++ b/support/timespec.h
> @@ -48,7 +48,7 @@ void test_timespec_equal_or_after_impl (const char *file, int line,
> const struct timespec left,
> const struct timespec right);
>
> -long support_timespec_ns (struct timespec time);
> +time_t support_timespec_ns (struct timespec time);
>
> struct timespec support_timespec_normalize (struct timespec time);
>
> diff --git a/support/tst-timespec.c b/support/tst-timespec.c
> index 71423555a9..ac5ed228ba 100644
> --- a/support/tst-timespec.c
> +++ b/support/tst-timespec.c
> @@ -19,13 +19,14 @@
> #include <support/timespec.h>
> #include <support/check.h>
> #include <limits.h>
> +#include <intprops.h>
>
> #define TIMESPEC_HZ 1000000000
>
> struct timespec_ns_test_case
> {
> struct timespec time;
> - long time_ns;
> + time_t time_ns;
> };
>
Ok.
> struct timespec_norm_test_case
> @@ -43,6 +44,9 @@ struct timespec_test_case
> int result;
> };
>
> +#define TIME_T_MIN TYPE_MINIMUM (time_t)
> +#define TIME_T_MAX TYPE_MAXIMUM (time_t)
> +
> /* Test cases for timespec_ns */
> struct timespec_ns_test_case ns_cases[] = {
> {.time = {.tv_sec = 0, .tv_nsec = 0},
> @@ -73,36 +77,42 @@ struct timespec_ns_test_case ns_cases[] = {
> .time_ns = -TIMESPEC_HZ + 1,
> },
> /* Overflow bondary by 2 */
> - {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ, .tv_nsec = LONG_MAX%TIMESPEC_HZ - 1},
> - .time_ns = LONG_MAX - 1,
> + {.time = {.tv_sec = TIME_T_MAX / TIMESPEC_HZ,
> + .tv_nsec = TIME_T_MAX % TIMESPEC_HZ - 1},
> + .time_ns = TIME_T_MAX - 1,
> },
> /* Overflow bondary */
> - {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ, .tv_nsec = LONG_MAX%TIMESPEC_HZ},
> - .time_ns = LONG_MAX,
> + {.time = {.tv_sec = TIME_T_MAX / TIMESPEC_HZ,
> + .tv_nsec = TIME_T_MAX % TIMESPEC_HZ},
> + .time_ns = TIME_T_MAX,
> },
> /* Underflow bondary by 1 */
> - {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ, .tv_nsec = LONG_MIN%TIMESPEC_HZ + 1},
> - .time_ns = LONG_MIN + 1,
> + {.time = {.tv_sec = TIME_T_MIN / TIMESPEC_HZ,
> + .tv_nsec = TIME_T_MIN % TIMESPEC_HZ + 1},
> + .time_ns = TIME_T_MIN + 1,
> },
> /* Underflow bondary */
> - {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ, .tv_nsec = LONG_MIN%TIMESPEC_HZ},
> - .time_ns = LONG_MIN,
> + {.time = {.tv_sec = TIME_T_MIN / TIMESPEC_HZ,
> + .tv_nsec = TIME_T_MIN % TIMESPEC_HZ},
> + .time_ns = TIME_T_MIN,
> },
> /* Multiplication overflow */
> - {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ + 1, .tv_nsec = 1},
> - .time_ns = LONG_MAX,
> + {.time = {.tv_sec = TIME_T_MAX / TIMESPEC_HZ + 1, .tv_nsec = 1},
> + .time_ns = TIME_T_MAX,
> },
> /* Multiplication underflow */
> - {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ - 1, .tv_nsec = -1},
> - .time_ns = LONG_MIN,
> + {.time = {.tv_sec = TIME_T_MIN / TIMESPEC_HZ - 1, .tv_nsec = -1},
> + .time_ns = TIME_T_MIN,
> },
> /* Sum overflows */
> - {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ, .tv_nsec = LONG_MAX%TIMESPEC_HZ + 1},
> - .time_ns = LONG_MAX,
> + {.time = {.tv_sec = TIME_T_MAX / TIMESPEC_HZ,
> + .tv_nsec = TIME_T_MAX % TIMESPEC_HZ + 1},
> + .time_ns = TIME_T_MAX,
> },
> /* Sum underflow */
> - {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ, .tv_nsec = LONG_MIN%TIMESPEC_HZ - 1},
> - .time_ns = LONG_MIN,
> + {.time = {.tv_sec = TIME_T_MIN / TIMESPEC_HZ,
> + .tv_nsec = TIME_T_MIN % TIMESPEC_HZ - 1},
> + .time_ns = TIME_T_MIN,
> }
> };
>
Please don't mix styles here.
> @@ -144,28 +154,28 @@ struct timespec_norm_test_case norm_cases[] = {
> .norm = {.tv_sec = -2, .tv_nsec = -1}
> },
> /* Overflow bondary by 2 */
> - {.time = {.tv_sec = LONG_MAX - 2, .tv_nsec = TIMESPEC_HZ + 1},
> - .norm = {.tv_sec = LONG_MAX - 1, 1},
> + {.time = {.tv_sec = TIME_T_MAX - 2, .tv_nsec = TIMESPEC_HZ + 1},
> + .norm = {.tv_sec = TIME_T_MAX - 1, 1},
> },
> /* Overflow bondary by 1 */
> - {.time = {.tv_sec = LONG_MAX - 1, .tv_nsec = TIMESPEC_HZ + 1},
> - .norm = {.tv_sec = LONG_MAX, .tv_nsec = 1},
> + {.time = {.tv_sec = TIME_T_MAX - 1, .tv_nsec = TIMESPEC_HZ + 1},
> + .norm = {.tv_sec = TIME_T_MAX, .tv_nsec = 1},
> },
> /* Underflow bondary by 2 */
> - {.time = {.tv_sec = LONG_MIN + 2, .tv_nsec = -TIMESPEC_HZ - 1},
> - .norm = {.tv_sec = LONG_MIN + 1, -1},
> + {.time = {.tv_sec = TIME_T_MIN + 2, .tv_nsec = -TIMESPEC_HZ - 1},
> + .norm = {.tv_sec = TIME_T_MIN + 1, -1},
> },
> /* Underflow bondary by 1 */
> - {.time = {.tv_sec = LONG_MIN + 1, .tv_nsec = -TIMESPEC_HZ - 1},
> - .norm = {.tv_sec = LONG_MIN, .tv_nsec = -1},
> + {.time = {.tv_sec = TIME_T_MIN + 1, .tv_nsec = -TIMESPEC_HZ - 1},
> + .norm = {.tv_sec = TIME_T_MIN, .tv_nsec = -1},
> },
> /* SUM overflow */
> - {.time = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> - .norm = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ - 1},
> + {.time = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ},
> + .norm = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ - 1},
> },
> /* SUM underflow */
> - {.time = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> - .norm = {.tv_sec = LONG_MIN, .tv_nsec = -1 * (TIMESPEC_HZ - 1)},
> + {.time = {.tv_sec = TIME_T_MIN, .tv_nsec = -TIMESPEC_HZ},
> + .norm = {.tv_sec = TIME_T_MIN, .tv_nsec = -1 * (TIMESPEC_HZ - 1)},
> }
> };
>
OK.
> @@ -243,39 +253,41 @@ struct timespec_test_case check_cases[] = {
> },
> /* Maximum/Minimum long values */
> /* 14 */
> - {.expected = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ - 1},
> - .observed = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ - 2},
> + {.expected = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ - 1},
> + .observed = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ - 2},
> .upper_bound = 1, .lower_bound = .9, .result = 1,
> },
> /* 15 - support_timespec_ns overflow */
> - {.expected = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> - .observed = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> + {.expected = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ},
> + .observed = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ},
> .upper_bound = 1, .lower_bound = 1, .result = 1,
> },
> /* 16 - support_timespec_ns overflow + underflow */
> - {.expected = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> - .observed = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> + {.expected = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ},
> + .observed = {.tv_sec = TIME_T_MIN, .tv_nsec = -TIMESPEC_HZ},
> .upper_bound = 1, .lower_bound = 1, .result = 0,
> },
> /* 17 - support_timespec_ns underflow */
> - {.expected = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> - .observed = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> + {.expected = {.tv_sec = TIME_T_MIN, .tv_nsec = -TIMESPEC_HZ},
> + .observed = {.tv_sec = TIME_T_MIN, .tv_nsec = -TIMESPEC_HZ},
> .upper_bound = 1, .lower_bound = 1, .result = 1,
> },
> /* 18 - support_timespec_ns underflow + overflow */
> - {.expected = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ},
> - .observed = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ},
> + {.expected = {.tv_sec = TIME_T_MIN, .tv_nsec = -TIMESPEC_HZ},
> + .observed = {.tv_sec = TIME_T_MAX, .tv_nsec = TIMESPEC_HZ},
> .upper_bound = 1, .lower_bound = 1, .result = 0,
> },
> /* 19 - Biggest division */
> - {.expected = {.tv_sec = LONG_MAX / TIMESPEC_HZ , .tv_nsec = TIMESPEC_HZ - 1},
> + {.expected = {.tv_sec = TIME_T_MAX / TIMESPEC_HZ,
> + .tv_nsec = TIMESPEC_HZ - 1},
> .observed = {.tv_sec = 0, .tv_nsec = 1},
> .upper_bound = 1, .lower_bound = 1.0842021724855044e-19, .result = 1,
> },
> /* 20 - Lowest division */
> {.expected = {.tv_sec = 0, .tv_nsec = 1},
> - .observed = {.tv_sec = LONG_MAX / TIMESPEC_HZ , .tv_nsec = TIMESPEC_HZ - 1},
> - .upper_bound = LONG_MAX, .lower_bound = 1, .result = 1,
> + .observed = {.tv_sec = TIME_T_MAX / TIMESPEC_HZ,
> + .tv_nsec = TIMESPEC_HZ - 1},
> + .upper_bound = TIME_T_MAX, .lower_bound = 1, .result = 1,
> },
> };
>
> @@ -288,6 +300,7 @@ do_test (void)
> printf("Testing support_timespec_ns\n");
> for (i = 0; i < ntests; i++)
> {
> + printf("Test case %d\n", i);
> TEST_COMPARE (support_timespec_ns (ns_cases[i].time),
> ns_cases[i].time_ns);
> }
> @@ -297,6 +310,7 @@ do_test (void)
> printf("Testing support_timespec_normalize\n");
> for (i = 0; i < ntests; i++)
> {
> + printf("Test case %d\n", i);
> result = support_timespec_normalize (norm_cases[i].time);
> TEST_COMPARE (norm_cases[i].norm.tv_sec, result.tv_sec);
> TEST_COMPARE (norm_cases[i].norm.tv_nsec, result.tv_nsec);
OK.
---
Lucas A. M. Magalhães
^ permalink raw reply [flat|nested] 44+ messages in thread