* [PATCH v2] Fix time/tst-cpuclock1 intermitent failures
@ 2020-02-06 14:48 Lucas A. M. Magalhaes
2020-02-17 16:44 ` Lucas A. M. Magalhaes
` (2 more replies)
0 siblings, 3 replies; 44+ messages in thread
From: Lucas A. M. Magalhaes @ 2020-02-06 14:48 UTC (permalink / raw)
To: libc-alpha; +Cc: codonell
This test fails intermittently in systems with heavy load as
CLOCK_PROCESS_CPUTIME_ID is subject to scheduler pressure. Thus the
test boundaries where relaxed to keep it from fail on this systems.
A refactor of the spent time checking was made with some support
functions. With the advantage to represent time jitter in percent
of the target.
The values used by the test boundaries are all empirical.
---
Hi,
Please Carlos see if this is what you asked.
I spent sometime gathering the spent times to find the values
for the boundaries. From this I selected values that will fail less
than 1% of the time, in the tested machines.
Also as I found the spent time deviation completely asymmetrical
I choose to separate the values in upper and lower bounds.
changes from V2:
- Add support functions
support/Makefile | 1 +
support/cpuclock.c | 51 ++++++++++++++++++++++++++++++++++++++++++++
support/cpuclock.h | 30 ++++++++++++++++++++++++++
time/tst-cpuclock1.c | 43 ++++++++++---------------------------
4 files changed, 93 insertions(+), 32 deletions(-)
create mode 100644 support/cpuclock.c
create mode 100644 support/cpuclock.h
diff --git a/support/Makefile b/support/Makefile
index 3325feb790..b308fe0856 100644
--- a/support/Makefile
+++ b/support/Makefile
@@ -31,6 +31,7 @@ libsupport-routines = \
check_dns_packet \
check_hostent \
check_netent \
+ cpuclock \
delayed_exit \
ignore_stderr \
next_to_fault \
diff --git a/support/cpuclock.c b/support/cpuclock.c
new file mode 100644
index 0000000000..f40c7e8d4a
--- /dev/null
+++ b/support/cpuclock.c
@@ -0,0 +1,51 @@
+/* Support functions for cpuclock tests.
+ Copyright (C) 2018-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 "cpuclock.h"
+#include <stdlib.h>
+
+#define T_1s 1000000000.0
+
+struct timespec time_normalize(struct timespec t) {
+ int diff;
+ diff = (t.tv_nsec / T_1s);
+ t.tv_sec += diff;
+ t.tv_nsec += -(diff * T_1s);
+ return t;
+}
+
+struct timespec time_add(struct timespec a, struct timespec b) {
+ struct timespec s = {.tv_sec = a.tv_sec + b.tv_sec,
+ .tv_nsec = a.tv_nsec + b.tv_nsec};
+ return time_normalize(s);
+}
+
+struct timespec time_sub(struct timespec a, struct timespec b) {
+ struct timespec d = {.tv_sec = a.tv_sec - b.tv_sec,
+ .tv_nsec = a.tv_nsec - b.tv_nsec};
+ return time_normalize(d);
+}
+
+int percent_diff_check(struct timespec base, struct timespec dev,
+ float upper_bound, float lower_bound) {
+ double timea = base.tv_sec + base.tv_nsec / T_1s;
+ double timeb = dev.tv_sec + dev.tv_nsec / T_1s;
+ double diff = (timea - timeb) / (0.5 * (timea + timeb));
+ return (diff >= -upper_bound && diff <= lower_bound );
+}
+
diff --git a/support/cpuclock.h b/support/cpuclock.h
new file mode 100644
index 0000000000..2505fbdcff
--- /dev/null
+++ b/support/cpuclock.h
@@ -0,0 +1,30 @@
+/* Support functions for cpuclock tests.
+ Copyright (C) 2018-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/>. */
+
+#ifndef SUPPORT_CPUCLOCK_H
+#define SUPPORT_CPUCLOCK_H
+
+#include <time.h>
+
+struct timespec time_normalize(struct timespec t);
+struct timespec time_add(struct timespec a, struct timespec b);
+struct timespec time_sub(struct timespec a, struct timespec b);
+int percent_diff_check(struct timespec base, struct timespec dev,
+ float upper_bound, float lower_bound);
+
+#endif /* SUPPORT_CPUCLOCK_H */
diff --git a/time/tst-cpuclock1.c b/time/tst-cpuclock1.c
index 0120906f23..4051de1646 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/cpuclock.h>
/* This function is intended to rack up both user and system time. */
static void
@@ -155,19 +156,11 @@ 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)
+ struct timespec diff = time_sub(after, before);
+ if (!percent_diff_check(sleeptime, diff, .3, 2))
{
printf ("before - after %ju.%.9ju outside reasonable range\n",
- (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
+ (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
result = 1;
}
@@ -194,19 +187,11 @@ 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)
+ diff = time_sub(afterns, after);
+ if (!percent_diff_check(sleeptime, diff, .6, .34))
{
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;
}
}
@@ -241,20 +226,14 @@ do_test (void)
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)
+ diff = time_sub(dead, after);
+ sleeptime.tv_nsec = 100000000;
+ if (!percent_diff_check(sleeptime, diff, .6, .36))
{
printf ("dead - after %ju.%.9ju outside reasonable range\n",
- (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
+ (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
result = 1;
}
-
/* Now reap the child and verify that its clock is no longer valid. */
{
int x;
--
2.20.1
^ permalink raw reply related [flat|nested] 44+ messages in thread
* Re: [PATCH v2] Fix time/tst-cpuclock1 intermitent failures
2020-02-06 14:48 [PATCH v2] Fix time/tst-cpuclock1 intermitent failures Lucas A. M. Magalhaes
@ 2020-02-17 16:44 ` Lucas A. M. Magalhaes
2020-02-18 12:44 ` Adhemerval Zanella
2020-02-20 18:17 ` [PATCH v3] " Lucas A. M. Magalhaes
2 siblings, 0 replies; 44+ messages in thread
From: Lucas A. M. Magalhaes @ 2020-02-17 16:44 UTC (permalink / raw)
To: libc-alpha; +Cc: codonell
Quoting Lucas A. M. Magalhaes (2020-02-06 11:48:19)
> This test fails intermittently in systems with heavy load as
> CLOCK_PROCESS_CPUTIME_ID is subject to scheduler pressure. Thus the
> test boundaries where relaxed to keep it from fail on this systems.
>
> A refactor of the spent time checking was made with some support
> functions. With the advantage to represent time jitter in percent
> of the target.
>
> The values used by the test boundaries are all empirical.
>
> ---
Ping.
>
> Hi,
>
> Please Carlos see if this is what you asked.
>
> I spent sometime gathering the spent times to find the values
> for the boundaries. From this I selected values that will fail less
> than 1% of the time, in the tested machines.
>
> Also as I found the spent time deviation completely asymmetrical
> I choose to separate the values in upper and lower bounds.
>
> changes from V2:
> - Add support functions
>
> support/Makefile | 1 +
> support/cpuclock.c | 51 ++++++++++++++++++++++++++++++++++++++++++++
> support/cpuclock.h | 30 ++++++++++++++++++++++++++
> time/tst-cpuclock1.c | 43 ++++++++++---------------------------
> 4 files changed, 93 insertions(+), 32 deletions(-)
> create mode 100644 support/cpuclock.c
> create mode 100644 support/cpuclock.h
>
> diff --git a/support/Makefile b/support/Makefile
> index 3325feb790..b308fe0856 100644
> --- a/support/Makefile
> +++ b/support/Makefile
> @@ -31,6 +31,7 @@ libsupport-routines = \
> check_dns_packet \
> check_hostent \
> check_netent \
> + cpuclock \
> delayed_exit \
> ignore_stderr \
> next_to_fault \
> diff --git a/support/cpuclock.c b/support/cpuclock.c
> new file mode 100644
> index 0000000000..f40c7e8d4a
> --- /dev/null
> +++ b/support/cpuclock.c
> @@ -0,0 +1,51 @@
> +/* Support functions for cpuclock tests.
> + Copyright (C) 2018-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 "cpuclock.h"
> +#include <stdlib.h>
> +
> +#define T_1s 1000000000.0
> +
> +struct timespec time_normalize(struct timespec t) {
> + int diff;
> + diff = (t.tv_nsec / T_1s);
> + t.tv_sec += diff;
> + t.tv_nsec += -(diff * T_1s);
> + return t;
> +}
> +
> +struct timespec time_add(struct timespec a, struct timespec b) {
> + struct timespec s = {.tv_sec = a.tv_sec + b.tv_sec,
> + .tv_nsec = a.tv_nsec + b.tv_nsec};
> + return time_normalize(s);
> +}
> +
> +struct timespec time_sub(struct timespec a, struct timespec b) {
> + struct timespec d = {.tv_sec = a.tv_sec - b.tv_sec,
> + .tv_nsec = a.tv_nsec - b.tv_nsec};
> + return time_normalize(d);
> +}
> +
> +int percent_diff_check(struct timespec base, struct timespec dev,
> + float upper_bound, float lower_bound) {
> + double timea = base.tv_sec + base.tv_nsec / T_1s;
> + double timeb = dev.tv_sec + dev.tv_nsec / T_1s;
> + double diff = (timea - timeb) / (0.5 * (timea + timeb));
> + return (diff >= -upper_bound && diff <= lower_bound );
> +}
> +
> diff --git a/support/cpuclock.h b/support/cpuclock.h
> new file mode 100644
> index 0000000000..2505fbdcff
> --- /dev/null
> +++ b/support/cpuclock.h
> @@ -0,0 +1,30 @@
> +/* Support functions for cpuclock tests.
> + Copyright (C) 2018-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/>. */
> +
> +#ifndef SUPPORT_CPUCLOCK_H
> +#define SUPPORT_CPUCLOCK_H
> +
> +#include <time.h>
> +
> +struct timespec time_normalize(struct timespec t);
> +struct timespec time_add(struct timespec a, struct timespec b);
> +struct timespec time_sub(struct timespec a, struct timespec b);
> +int percent_diff_check(struct timespec base, struct timespec dev,
> + float upper_bound, float lower_bound);
> +
> +#endif /* SUPPORT_CPUCLOCK_H */
> diff --git a/time/tst-cpuclock1.c b/time/tst-cpuclock1.c
> index 0120906f23..4051de1646 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/cpuclock.h>
>
> /* This function is intended to rack up both user and system time. */
> static void
> @@ -155,19 +156,11 @@ 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)
> + struct timespec diff = time_sub(after, before);
> + if (!percent_diff_check(sleeptime, diff, .3, 2))
> {
> printf ("before - after %ju.%.9ju outside reasonable range\n",
> - (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> + (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> result = 1;
> }
>
> @@ -194,19 +187,11 @@ 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)
> + diff = time_sub(afterns, after);
> + if (!percent_diff_check(sleeptime, diff, .6, .34))
> {
> 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;
> }
> }
> @@ -241,20 +226,14 @@ do_test (void)
> 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)
> + diff = time_sub(dead, after);
> + sleeptime.tv_nsec = 100000000;
> + if (!percent_diff_check(sleeptime, diff, .6, .36))
> {
> printf ("dead - after %ju.%.9ju outside reasonable range\n",
> - (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> + (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> result = 1;
> }
> -
> /* Now reap the child and verify that its clock is no longer valid. */
> {
> int x;
> --
> 2.20.1
>
^ permalink raw reply [flat|nested] 44+ messages in thread
* Re: [PATCH v2] Fix time/tst-cpuclock1 intermitent failures
2020-02-06 14:48 [PATCH v2] Fix time/tst-cpuclock1 intermitent failures Lucas A. M. Magalhaes
2020-02-17 16:44 ` Lucas A. M. Magalhaes
@ 2020-02-18 12:44 ` Adhemerval Zanella
2020-02-19 16:42 ` Lucas A. M. Magalhaes
2020-02-20 18:17 ` [PATCH v3] " Lucas A. M. Magalhaes
2 siblings, 1 reply; 44+ messages in thread
From: Adhemerval Zanella @ 2020-02-18 12:44 UTC (permalink / raw)
To: libc-alpha
On 06/02/2020 11:48, 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 where relaxed to keep it from fail on this systems.
>
> A refactor of the spent time checking was made with some support
> functions. With the advantage to represent time jitter in percent
> of the target.
>
> The values used by the test boundaries are all empirical.
>
> ---
>
> Hi,
>
> Please Carlos see if this is what you asked.
>
> I spent sometime gathering the spent times to find the values
> for the boundaries. From this I selected values that will fail less
> than 1% of the time, in the tested machines.
>
> Also as I found the spent time deviation completely asymmetrical
> I choose to separate the values in upper and lower bounds.
>
> changes from V2:
> - Add support functions
None of the files follow the code and style guideline [1].
[1] https://sourceware.org/glibc/wiki/Style_and_Conventions
>
> support/Makefile | 1 +
> support/cpuclock.c | 51 ++++++++++++++++++++++++++++++++++++++++++++
> support/cpuclock.h | 30 ++++++++++++++++++++++++++
> time/tst-cpuclock1.c | 43 ++++++++++---------------------------
> 4 files changed, 93 insertions(+), 32 deletions(-)
> create mode 100644 support/cpuclock.c
> create mode 100644 support/cpuclock.h
>
> diff --git a/support/Makefile b/support/Makefile
> index 3325feb790..b308fe0856 100644
> --- a/support/Makefile
> +++ b/support/Makefile
> @@ -31,6 +31,7 @@ libsupport-routines = \
> check_dns_packet \
> check_hostent \
> check_netent \
> + cpuclock \
> delayed_exit \
> ignore_stderr \
> next_to_fault \
> diff --git a/support/cpuclock.c b/support/cpuclock.c
> new file mode 100644
> index 0000000000..f40c7e8d4a
> --- /dev/null
> +++ b/support/cpuclock.c
> @@ -0,0 +1,51 @@
> +/* Support functions for cpuclock tests.
> + Copyright (C) 2018-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 "cpuclock.h"
> +#include <stdlib.h>
> +
> +#define T_1s 1000000000.0
> +
> +struct timespec time_normalize(struct timespec t) {
> + int diff;
> + diff = (t.tv_nsec / T_1s);
> + t.tv_sec += diff;
> + t.tv_nsec += -(diff * T_1s);
> + return t;
> +}
> +
> +struct timespec time_add(struct timespec a, struct timespec b) {
> + struct timespec s = {.tv_sec = a.tv_sec + b.tv_sec,
> + .tv_nsec = a.tv_nsec + b.tv_nsec};
> + return time_normalize(s);
> +}
> +
> +struct timespec time_sub(struct timespec a, struct timespec b) {
> + struct timespec d = {.tv_sec = a.tv_sec - b.tv_sec,
> + .tv_nsec = a.tv_nsec - b.tv_nsec};
> + return time_normalize(d);
> +}
I don't using float operation is the correct solution to handle both
invalid inputs and overflow results. We already have a working solution
(support/timespec-add.c and support/timespec-sub.c), why do you need
to add such functions?
> +
> +int percent_diff_check(struct timespec base, struct timespec dev,
> + float upper_bound, float lower_bound) {
> + double timea = base.tv_sec + base.tv_nsec / T_1s;
> + double timeb = dev.tv_sec + dev.tv_nsec / T_1s;
> + double diff = (timea - timeb) / (0.5 * (timea + timeb));
> + return (diff >= -upper_bound && diff <= lower_bound );
> +}
> +
Please add some description of what this function do. And I think
it would be better to normalize to nanoseconds instead of seconds
to avoid floating-point cancellation due the range difference.
Something like:
/* Return true if the DIFF time is within the ratio
[upper_bound, lower_bound] of DIFF time, or false otherwise.
For instance:
struct timespec diff = { 3, 94956 };
struct timespec base = { 4, 0 };
The call checks if the ratio of diff/base is within the
bounds of (0.65, 1.0) (i.e, if 'diff' is at least 65% of
the 'base' value).
support_timespec_check_in_range (base, diff, 1.0, 0.65); */
bool support_timespec_check_ratio (struct timespec base,
struct timespec diff,
double upper_bound,
double lower_bound)
{
assert (upper_bound >= lower_bound);
uint64_t base_norm = base.tv_sec * TIMESPEC_HZ + base.tv_nsec;
uint64_t diff_norm = diff.tv_sec * TIMESPEC_HZ + diff.tv_nsec;
double ratio = (double) base_norm / (double) diff_norm;
return ratio >= lower_bound && ratio <= upper_bound;
}
I think it should follow the libsupport name convention of prepending
'support_' on file name.
The same name convention should be used on the exported interfaces
(support_*).
And I see that using time_* is confusing because the underlying type
is a 'timespec'. On 'include/time.h' the type is used on function
name, I think we should do the same here.
> diff --git a/support/cpuclock.h b/support/cpuclock.h
> new file mode 100644
> index 0000000000..2505fbdcff
> --- /dev/null
> +++ b/support/cpuclock.h
> @@ -0,0 +1,30 @@
> +/* Support functions for cpuclock tests.
> + Copyright (C) 2018-2020 Free Software Foundation, Inc.
This implementation is not based on old tests, I think the copyright
years should be only 2020.
> + 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/>. */
> +
> +#ifndef SUPPORT_CPUCLOCK_H
> +#define SUPPORT_CPUCLOCK_H
> +
> +#include <time.h>
> +
> +struct timespec time_normalize(struct timespec t);
> +struct timespec time_add(struct timespec a, struct timespec b);
> +struct timespec time_sub(struct timespec a, struct timespec b);
> +int percent_diff_check(struct timespec base, struct timespec dev,
> + float upper_bound, float lower_bound);
> +
> +#endif /* SUPPORT_CPUCLOCK_H */
As before.
> diff --git a/time/tst-cpuclock1.c b/time/tst-cpuclock1.c
> index 0120906f23..4051de1646 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/cpuclock.h>
>
> /* This function is intended to rack up both user and system time. */
> static void
> @@ -155,19 +156,11 @@ 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)
> + struct timespec diff = time_sub(after, before);
> + if (!percent_diff_check(sleeptime, diff, .3, 2))
> {
> printf ("before - after %ju.%.9ju outside reasonable range\n",
> - (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> + (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> result = 1;
> }
>
> @@ -194,19 +187,11 @@ 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)
> + diff = time_sub(afterns, after);
> + if (!percent_diff_check(sleeptime, diff, .6, .34))
> {
> 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;
> }
> }
> @@ -241,20 +226,14 @@ do_test (void)
> 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)
> + diff = time_sub(dead, after);
> + sleeptime.tv_nsec = 100000000;
> + if (!percent_diff_check(sleeptime, diff, .6, .36))
> {
> printf ("dead - after %ju.%.9ju outside reasonable range\n",
> - (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> + (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> result = 1;
> }
> -
> /* Now reap the child and verify that its clock is no longer valid. */
> {
> int x;
>
^ permalink raw reply [flat|nested] 44+ messages in thread
* Re: [PATCH v2] Fix time/tst-cpuclock1 intermitent failures
2020-02-18 12:44 ` Adhemerval Zanella
@ 2020-02-19 16:42 ` Lucas A. M. Magalhaes
2020-02-19 18:51 ` Adhemerval Zanella
0 siblings, 1 reply; 44+ messages in thread
From: Lucas A. M. Magalhaes @ 2020-02-19 16:42 UTC (permalink / raw)
To: Adhemerval Zanella, libc-alpha
Hi,
Thanks for the review :).
Quoting Adhemerval Zanella (2020-02-18 09:44:08)
>
>
> On 06/02/2020 11:48, 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 where relaxed to keep it from fail on this systems.
> >
> > A refactor of the spent time checking was made with some support
> > functions. With the advantage to represent time jitter in percent
> > of the target.
> >
> > The values used by the test boundaries are all empirical.
> >
> > ---
> >
> > Hi,
> >
> > Please Carlos see if this is what you asked.
> >
> > I spent sometime gathering the spent times to find the values
> > for the boundaries. From this I selected values that will fail less
> > than 1% of the time, in the tested machines.
> >
> > Also as I found the spent time deviation completely asymmetrical
> > I choose to separate the values in upper and lower bounds.
> >
> > changes from V2:
> > - Add support functions
>
> None of the files follow the code and style guideline [1].
>
> [1] https://sourceware.org/glibc/wiki/Style_and_Conventions
>
OK, Sorry about that.
> >
> > support/Makefile | 1 +
> > support/cpuclock.c | 51 ++++++++++++++++++++++++++++++++++++++++++++
> > support/cpuclock.h | 30 ++++++++++++++++++++++++++
> > time/tst-cpuclock1.c | 43 ++++++++++---------------------------
> > 4 files changed, 93 insertions(+), 32 deletions(-)
> > create mode 100644 support/cpuclock.c
> > create mode 100644 support/cpuclock.h
> >
> > diff --git a/support/Makefile b/support/Makefile
> > index 3325feb790..b308fe0856 100644
> > --- a/support/Makefile
> > +++ b/support/Makefile
> > @@ -31,6 +31,7 @@ libsupport-routines = \
> > check_dns_packet \
> > check_hostent \
> > check_netent \
> > + cpuclock \
> > delayed_exit \
> > ignore_stderr \
> > next_to_fault \
> > diff --git a/support/cpuclock.c b/support/cpuclock.c
> > new file mode 100644
> > index 0000000000..f40c7e8d4a
> > --- /dev/null
> > +++ b/support/cpuclock.c
> > @@ -0,0 +1,51 @@
> > +/* Support functions for cpuclock tests.
> > + Copyright (C) 2018-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 "cpuclock.h"
> > +#include <stdlib.h>
> > +
> > +#define T_1s 1000000000.0
> > +
> > +struct timespec time_normalize(struct timespec t) {
> > + int diff;
> > + diff = (t.tv_nsec / T_1s);
> > + t.tv_sec += diff;
> > + t.tv_nsec += -(diff * T_1s);
> > + return t;
> > +}
> > +
> > +struct timespec time_add(struct timespec a, struct timespec b) {
> > + struct timespec s = {.tv_sec = a.tv_sec + b.tv_sec,
> > + .tv_nsec = a.tv_nsec + b.tv_nsec};
> > + return time_normalize(s);
> > +}
> > +
> > +struct timespec time_sub(struct timespec a, struct timespec b) {
> > + struct timespec d = {.tv_sec = a.tv_sec - b.tv_sec,
> > + .tv_nsec = a.tv_nsec - b.tv_nsec};
> > + return time_normalize(d);
> > +}
>
> I don't using float operation is the correct solution to handle both
> invalid inputs and overflow results. We already have a working solution
> (support/timespec-add.c and support/timespec-sub.c), why do you need
> to add such functions?
>
Well I actually didn't notice them, as I was suggested to implement it.
Thanks for pointing it out. I will remove them and use the existing
solution.
> > +
> > +int percent_diff_check(struct timespec base, struct timespec dev,
> > + float upper_bound, float lower_bound) {
> > + double timea = base.tv_sec + base.tv_nsec / T_1s;
> > + double timeb = dev.tv_sec + dev.tv_nsec / T_1s;
> > + double diff = (timea - timeb) / (0.5 * (timea + timeb));
> > + return (diff >= -upper_bound && diff <= lower_bound );
> > +}
> > +
>
> Please add some description of what this function do. And I think
> it would be better to normalize to nanoseconds instead of seconds
> to avoid floating-point cancellation due the range difference.
I'm using double here because this "(timea + timeb)" was sometimes
overflowing.
IMHO this will not be used to check, or compute, really small jitter,
so floating-point cancellation should not be a problem. But if you see
that it's worth I could to change to long and use:
double diff = (timea - timeb) / max(timea, timeb);
instead of
double diff = (timea - timeb) / (0.5 * (timea + timeb));
> Something like:
>
> /* Return true if the DIFF time is within the ratio
IMHO it makes more sense to think in it as a relative difference rather
than in ration. As "diff time is x% bigger than base" instead of "diff
time is x% of the base". So I want to keep this approach.
> [upper_bound, lower_bound] of DIFF time, or false otherwise.
>
> For instance:
>
> struct timespec diff = { 3, 94956 };
> struct timespec base = { 4, 0 };
>
> The call checks if the ratio of diff/base is within the
> bounds of (0.65, 1.0) (i.e, if 'diff' is at least 65% of
> the 'base' value).
>
> support_timespec_check_in_range (base, diff, 1.0, 0.65); */
> bool support_timespec_check_ratio (struct timespec base,
> struct timespec diff,
> double upper_bound,
> double lower_bound)
> {
> assert (upper_bound >= lower_bound);
> uint64_t base_norm = base.tv_sec * TIMESPEC_HZ + base.tv_nsec;
> uint64_t diff_norm = diff.tv_sec * TIMESPEC_HZ + diff.tv_nsec;
> double ratio = (double) base_norm / (double) diff_norm;
> return ratio >= lower_bound && ratio <= upper_bound;
> }
>
>
> I think it should follow the libsupport name convention of prepending
> 'support_' on file name.
>
> The same name convention should be used on the exported interfaces
> (support_*).
>
> And I see that using time_* is confusing because the underlying type
> is a 'timespec'. On 'include/time.h' the type is used on function
> name, I think we should do the same here.
>
>
Ok.
> > diff --git a/support/cpuclock.h b/support/cpuclock.h
> > new file mode 100644
> > index 0000000000..2505fbdcff
> > --- /dev/null
> > +++ b/support/cpuclock.h
> > @@ -0,0 +1,30 @@
> > +/* Support functions for cpuclock tests.
> > + Copyright (C) 2018-2020 Free Software Foundation, Inc.
>
> This implementation is not based on old tests, I think the copyright
> years should be only 2020.
>
> > + 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/>. */
> > +
> > +#ifndef SUPPORT_CPUCLOCK_H
> > +#define SUPPORT_CPUCLOCK_H
> > +
> > +#include <time.h>
> > +
> > +struct timespec time_normalize(struct timespec t);
> > +struct timespec time_add(struct timespec a, struct timespec b);
> > +struct timespec time_sub(struct timespec a, struct timespec b);
> > +int percent_diff_check(struct timespec base, struct timespec dev,
> > + float upper_bound, float lower_bound);
> > +
> > +#endif /* SUPPORT_CPUCLOCK_H */
>
> As before.
>
> > diff --git a/time/tst-cpuclock1.c b/time/tst-cpuclock1.c
> > index 0120906f23..4051de1646 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/cpuclock.h>
> >
> > /* This function is intended to rack up both user and system time. */
> > static void
> > @@ -155,19 +156,11 @@ 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)
> > + struct timespec diff = time_sub(after, before);
> > + if (!percent_diff_check(sleeptime, diff, .3, 2))
> > {
> > printf ("before - after %ju.%.9ju outside reasonable range\n",
> > - (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> > + (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> > result = 1;
> > }
> >
> > @@ -194,19 +187,11 @@ 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)
> > + diff = time_sub(afterns, after);
> > + if (!percent_diff_check(sleeptime, diff, .6, .34))
> > {
> > 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;
> > }
> > }
> > @@ -241,20 +226,14 @@ do_test (void)
> > 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)
> > + diff = time_sub(dead, after);
> > + sleeptime.tv_nsec = 100000000;
> > + if (!percent_diff_check(sleeptime, diff, .6, .36))
> > {
> > printf ("dead - after %ju.%.9ju outside reasonable range\n",
> > - (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> > + (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> > result = 1;
> > }
> > -
> > /* Now reap the child and verify that its clock is no longer valid. */
> > {
> > int x;
> >
^ permalink raw reply [flat|nested] 44+ messages in thread
* Re: [PATCH v2] Fix time/tst-cpuclock1 intermitent failures
2020-02-19 16:42 ` Lucas A. M. Magalhaes
@ 2020-02-19 18:51 ` Adhemerval Zanella
0 siblings, 0 replies; 44+ messages in thread
From: Adhemerval Zanella @ 2020-02-19 18:51 UTC (permalink / raw)
To: Lucas A. M. Magalhaes, libc-alpha
On 19/02/2020 13:42, Lucas A. M. Magalhaes wrote:
> Hi,
> Thanks for the review :).
>
> Quoting Adhemerval Zanella (2020-02-18 09:44:08)
>>
>>
>> On 06/02/2020 11:48, 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 where relaxed to keep it from fail on this systems.
>>>
>>> A refactor of the spent time checking was made with some support
>>> functions. With the advantage to represent time jitter in percent
>>> of the target.
>>>
>>> The values used by the test boundaries are all empirical.
>>>
>>> ---
>>>
>>> Hi,
>>>
>>> Please Carlos see if this is what you asked.
>>>
>>> I spent sometime gathering the spent times to find the values
>>> for the boundaries. From this I selected values that will fail less
>>> than 1% of the time, in the tested machines.
>>>
>>> Also as I found the spent time deviation completely asymmetrical
>>> I choose to separate the values in upper and lower bounds.
>>>
>>> changes from V2:
>>> - Add support functions
>>
>> None of the files follow the code and style guideline [1].
>>
>> [1] https://sourceware.org/glibc/wiki/Style_and_Conventions
>>
>
> OK, Sorry about that.
>
>>>
>>> support/Makefile | 1 +
>>> support/cpuclock.c | 51 ++++++++++++++++++++++++++++++++++++++++++++
>>> support/cpuclock.h | 30 ++++++++++++++++++++++++++
>>> time/tst-cpuclock1.c | 43 ++++++++++---------------------------
>>> 4 files changed, 93 insertions(+), 32 deletions(-)
>>> create mode 100644 support/cpuclock.c
>>> create mode 100644 support/cpuclock.h
>>>
>>> diff --git a/support/Makefile b/support/Makefile
>>> index 3325feb790..b308fe0856 100644
>>> --- a/support/Makefile
>>> +++ b/support/Makefile
>>> @@ -31,6 +31,7 @@ libsupport-routines = \
>>> check_dns_packet \
>>> check_hostent \
>>> check_netent \
>>> + cpuclock \
>>> delayed_exit \
>>> ignore_stderr \
>>> next_to_fault \
>>> diff --git a/support/cpuclock.c b/support/cpuclock.c
>>> new file mode 100644
>>> index 0000000000..f40c7e8d4a
>>> --- /dev/null
>>> +++ b/support/cpuclock.c
>>> @@ -0,0 +1,51 @@
>>> +/* Support functions for cpuclock tests.
>>> + Copyright (C) 2018-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 "cpuclock.h"
>>> +#include <stdlib.h>
>>> +
>>> +#define T_1s 1000000000.0
>>> +
>>> +struct timespec time_normalize(struct timespec t) {
>>> + int diff;
>>> + diff = (t.tv_nsec / T_1s);
>>> + t.tv_sec += diff;
>>> + t.tv_nsec += -(diff * T_1s);
>>> + return t;
>>> +}
>>> +
>>> +struct timespec time_add(struct timespec a, struct timespec b) {
>>> + struct timespec s = {.tv_sec = a.tv_sec + b.tv_sec,
>>> + .tv_nsec = a.tv_nsec + b.tv_nsec};
>>> + return time_normalize(s);
>>> +}
>>> +
>>> +struct timespec time_sub(struct timespec a, struct timespec b) {
>>> + struct timespec d = {.tv_sec = a.tv_sec - b.tv_sec,
>>> + .tv_nsec = a.tv_nsec - b.tv_nsec};
>>> + return time_normalize(d);
>>> +}
>>
>> I don't using float operation is the correct solution to handle both
>> invalid inputs and overflow results. We already have a working solution
>> (support/timespec-add.c and support/timespec-sub.c), why do you need
>> to add such functions?
>>
>
> Well I actually didn't notice them, as I was suggested to implement it.
> Thanks for pointing it out. I will remove them and use the existing
> solution.
>
>>> +
>>> +int percent_diff_check(struct timespec base, struct timespec dev,
>>> + float upper_bound, float lower_bound) {
>>> + double timea = base.tv_sec + base.tv_nsec / T_1s;
>>> + double timeb = dev.tv_sec + dev.tv_nsec / T_1s;
>>> + double diff = (timea - timeb) / (0.5 * (timea + timeb));
>>> + return (diff >= -upper_bound && diff <= lower_bound );
>>> +}
>>> +
>>
>> Please add some description of what this function do. And I think
>> it would be better to normalize to nanoseconds instead of seconds
>> to avoid floating-point cancellation due the range difference.
>
> I'm using double here because this "(timea + timeb)" was sometimes
> overflowing.
>
> IMHO this will not be used to check, or compute, really small jitter,
> so floating-point cancellation should not be a problem. But if you see
> that it's worth I could to change to long and use:
>
> double diff = (timea - timeb) / max(timea, timeb);
>
> instead of
>
> double diff = (timea - timeb) / (0.5 * (timea + timeb));
>
>> Something like:
>>
>> /* Return true if the DIFF time is within the ratio
>
> IMHO it makes more sense to think in it as a relative difference rather
> than in ration. As "diff time is x% bigger than base" instead of "diff
> time is x% of the base". So I want to keep this approach.
But the idea of test refactoring is to check if value is in a bounded
range of another value, i.e, to check if the CPU time spent in the
created process is within an expected value.
I personally think is quite confusing the function call:
percent_diff_check(sleeptime, diff, .6, .34)
Which is simplified to:
-0.6 <= (sleeptime - diff)/(0.5*(sleeptime + diff) <= 0.34
And the result will be negative iff diff is larger than sleeptime. And
this might happen iff the calling process is using more than one CPU
(so total number of CPU time will be higher than total sleep time
which assumes only one CPU).
Also, for such scenarios it really awkward to define the expected
threshold. For instance, assuming child process has two threads chewing
up CPU and the parent process sleeping for 0.5s. The result CPU
for child would be close to 1s, and with your formula the resulting
diff will be ~ -0.66. This is confusing to set the threshold on
such scenario.
With my suggestion, for diff time larger than base one you set a
lower positive threshold; while for diff time lower than base you
set a large higher positive threshold.
>
>> [upper_bound, lower_bound] of DIFF time, or false otherwise.
>>
>> For instance:
>>
>> struct timespec diff = { 3, 94956 };
>> struct timespec base = { 4, 0 };
>>
>> The call checks if the ratio of diff/base is within the
>> bounds of (0.65, 1.0) (i.e, if 'diff' is at least 65% of
>> the 'base' value).
>>
>> support_timespec_check_in_range (base, diff, 1.0, 0.65); */
>> bool support_timespec_check_ratio (struct timespec base,
>> struct timespec diff,
>> double upper_bound,
>> double lower_bound)
>> {
>> assert (upper_bound >= lower_bound);
>> uint64_t base_norm = base.tv_sec * TIMESPEC_HZ + base.tv_nsec;
>> uint64_t diff_norm = diff.tv_sec * TIMESPEC_HZ + diff.tv_nsec;
>> double ratio = (double) base_norm / (double) diff_norm;
>> return ratio >= lower_bound && ratio <= upper_bound;
>> }
In fact I think base_norm and diff_norm should be calculated as double
here.
>>
>>
>> I think it should follow the libsupport name convention of prepending
>> 'support_' on file name.
>>
>> The same name convention should be used on the exported interfaces
>> (support_*).
>>
>> And I see that using time_* is confusing because the underlying type
>> is a 'timespec'. On 'include/time.h' the type is used on function
>> name, I think we should do the same here.
>>
>>
>
> Ok.
>
>>> diff --git a/support/cpuclock.h b/support/cpuclock.h
>>> new file mode 100644
>>> index 0000000000..2505fbdcff
>>> --- /dev/null
>>> +++ b/support/cpuclock.h
>>> @@ -0,0 +1,30 @@
>>> +/* Support functions for cpuclock tests.
>>> + Copyright (C) 2018-2020 Free Software Foundation, Inc.
>>
>> This implementation is not based on old tests, I think the copyright
>> years should be only 2020.
>>
>>> + 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/>. */
>>> +
>>> +#ifndef SUPPORT_CPUCLOCK_H
>>> +#define SUPPORT_CPUCLOCK_H
>>> +
>>> +#include <time.h>
>>> +
>>> +struct timespec time_normalize(struct timespec t);
>>> +struct timespec time_add(struct timespec a, struct timespec b);
>>> +struct timespec time_sub(struct timespec a, struct timespec b);
>>> +int percent_diff_check(struct timespec base, struct timespec dev,
>>> + float upper_bound, float lower_bound);
>>> +
>>> +#endif /* SUPPORT_CPUCLOCK_H */
>>
>> As before.
>>
>>> diff --git a/time/tst-cpuclock1.c b/time/tst-cpuclock1.c
>>> index 0120906f23..4051de1646 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/cpuclock.h>
>>>
>>> /* This function is intended to rack up both user and system time. */
>>> static void
>>> @@ -155,19 +156,11 @@ 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)
>>> + struct timespec diff = time_sub(after, before);
>>> + if (!percent_diff_check(sleeptime, diff, .3, 2))
>>> {
>>> printf ("before - after %ju.%.9ju outside reasonable range\n",
>>> - (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
>>> + (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
>>> result = 1;
>>> }
>>>
>>> @@ -194,19 +187,11 @@ 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)
>>> + diff = time_sub(afterns, after);
>>> + if (!percent_diff_check(sleeptime, diff, .6, .34))
>>> {
>>> 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;
>>> }
>>> }
>>> @@ -241,20 +226,14 @@ do_test (void)
>>> 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)
>>> + diff = time_sub(dead, after);
>>> + sleeptime.tv_nsec = 100000000;
>>> + if (!percent_diff_check(sleeptime, diff, .6, .36))
>>> {
>>> printf ("dead - after %ju.%.9ju outside reasonable range\n",
>>> - (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
>>> + (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
>>> result = 1;
>>> }
>>> -
>>> /* Now reap the child and verify that its clock is no longer valid. */
>>> {
>>> int x;
>>>
^ permalink raw reply [flat|nested] 44+ messages in thread
* [PATCH v3] Fix time/tst-cpuclock1 intermitent failures
2020-02-06 14:48 [PATCH v2] Fix time/tst-cpuclock1 intermitent failures Lucas A. M. Magalhaes
2020-02-17 16:44 ` Lucas A. M. Magalhaes
2020-02-18 12:44 ` Adhemerval Zanella
@ 2020-02-20 18:17 ` Lucas A. M. Magalhaes
2020-03-04 19:24 ` Matheus Castanho
2020-03-10 16:20 ` [PATCH v4] " Lucas A. M. Magalhaes
2 siblings, 2 replies; 44+ messages in thread
From: Lucas A. M. Magalhaes @ 2020-02-20 18:17 UTC (permalink / raw)
To: libc-alpha; +Cc: adhemerval.zanella
This test fails intermittently in systems with heavy load as
CLOCK_PROCESS_CPUTIME_ID is subject to scheduler pressure. Thus the
test boundaries where relaxed to keep it from fail on this systems.
A refactor of the spent time checking was made with some support
functions. With the advantage to represent time jitter in percent
of the target.
The values used by the test boundaries are all empirical.
---
Hi,
changes on V3:
- refactor support functions
- use existing timespec-sub function
changes on V2:
- Add support functions
support/Makefile | 1 +
support/support_cpuclock.c | 58 ++++++++++++++++++++++++++++++++++++++
support/support_cpuclock.h | 28 ++++++++++++++++++
time/tst-cpuclock1.c | 47 +++++++++++-------------------
4 files changed, 103 insertions(+), 31 deletions(-)
create mode 100644 support/support_cpuclock.c
create mode 100644 support/support_cpuclock.h
diff --git a/support/Makefile b/support/Makefile
index a0304e6def..1e45d99b27 100644
--- a/support/Makefile
+++ b/support/Makefile
@@ -31,6 +31,7 @@ libsupport-routines = \
check_dns_packet \
check_hostent \
check_netent \
+ support_cpuclock \
delayed_exit \
ignore_stderr \
next_to_fault \
diff --git a/support/support_cpuclock.c b/support/support_cpuclock.c
new file mode 100644
index 0000000000..cd5212bc32
--- /dev/null
+++ b/support/support_cpuclock.c
@@ -0,0 +1,58 @@
+/* Support functions for cpuclock tests.
+ 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_cpuclock.h"
+#include <stdlib.h>
+#include <assert.h>
+
+#define TIMESPEC_HZ 1000000000.0
+
+/* Returns t normalized timespec with .tv_nsec < TIMESPEC_HZ
+ and the overflows added to .tv_sec. */
+struct timespec
+support_timespec_normalize (struct timespec t)
+{
+ int diff;
+ diff = (t.tv_nsec / TIMESPEC_HZ);
+ t.tv_sec += diff;
+ t.tv_nsec += -(diff * TIMESPEC_HZ);
+ return t;
+}
+
+/* Returns TRUE if diff to base ratio is within the specified bounds, and
+FALSE otherwise.
+For example the call
+
+support_timespec_check_ratio(base, diff, 1.2, .5);
+
+will check if
+
+.5 <= diff/base <= 1.2
+
+In other words it will check if diff time is within 50% to 120% of
+the base time. */
+int
+support_timespec_check_ratio (struct timespec base, struct timespec diff,
+ double upper_bound, double lower_bound)
+{
+ assert (upper_bound >= lower_bound);
+ double base_norm = base.tv_sec + base.tv_nsec / TIMESPEC_HZ;
+ double diff_norm = diff.tv_sec + diff.tv_nsec / TIMESPEC_HZ;
+ double ratio = diff_norm / base_norm;
+ return (ratio <= upper_bound && ratio >= lower_bound);
+}
diff --git a/support/support_cpuclock.h b/support/support_cpuclock.h
new file mode 100644
index 0000000000..a14bc91e3f
--- /dev/null
+++ b/support/support_cpuclock.h
@@ -0,0 +1,28 @@
+/* Support functions for cpuclock tests.
+ 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/>. */
+
+#ifndef SUPPORT_CPUCLOCK_H
+#define SUPPORT_CPUCLOCK_H
+
+#include <time.h>
+
+struct timespec support_timespec_normalize (struct timespec t);
+int support_timespec_check_ratio (struct timespec base, struct timespec diff,
+ double upper_bound, double lower_bound);
+
+#endif /* SUPPORT_CPUCLOCK_H */
diff --git a/time/tst-cpuclock1.c b/time/tst-cpuclock1.c
index 0120906f23..72450f71ee 100644
--- a/time/tst-cpuclock1.c
+++ b/time/tst-cpuclock1.c
@@ -26,6 +26,8 @@
#include <signal.h>
#include <stdint.h>
#include <sys/wait.h>
+#include <support/support_cpuclock.h>
+#include <support/timespec.h>
/* This function is intended to rack up both user and system time. */
static void
@@ -155,19 +157,13 @@ 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)
+ support_timespec_normalize(after);
+ support_timespec_normalize(before);
+ struct timespec diff = timespec_sub(after, before);
+ if (!support_timespec_check_ratio(sleeptime, diff, 1.3, .0025))
{
printf ("before - after %ju.%.9ju outside reasonable range\n",
- (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
+ (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
result = 1;
}
@@ -194,19 +190,12 @@ 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)
+ support_timespec_normalize(afterns);
+ diff = timespec_sub(afterns, after);
+ if (!support_timespec_check_ratio(sleeptime, diff, 1.6, .71))
{
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;
}
}
@@ -241,17 +230,13 @@ do_test (void)
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)
+ support_timespec_normalize(dead);
+ diff = timespec_sub(dead, after);
+ sleeptime.tv_nsec = 100000000;
+ if (!support_timespec_check_ratio(sleeptime, diff, 1.6, .7))
{
printf ("dead - after %ju.%.9ju outside reasonable range\n",
- (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
+ (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
result = 1;
}
--
2.20.1
^ permalink raw reply related [flat|nested] 44+ messages in thread
* Re: [PATCH v3] Fix time/tst-cpuclock1 intermitent failures
2020-02-20 18:17 ` [PATCH v3] " Lucas A. M. Magalhaes
@ 2020-03-04 19:24 ` Matheus Castanho
2020-03-06 17:31 ` Lucas A. M. Magalhaes
2020-03-10 16:20 ` [PATCH v4] " Lucas A. M. Magalhaes
1 sibling, 1 reply; 44+ messages in thread
From: Matheus Castanho @ 2020-03-04 19:24 UTC (permalink / raw)
To: Lucas A. M. Magalhaes, libc-alpha; +Cc: adhemerval.zanella
Hi Lucas,
I believe the main idea behind Carlos' initial suggestion was to make
something more generic that could also be used in other places. The
patch is following in this direction alright but I think there are still
a few details that could be improved in this regard. Comments below.
On 2/20/20 3:17 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 where relaxed to keep it from fail on this systems.
"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 represent time jitter in percent
> of the target.
>
> The values used by the test boundaries are all empirical.
>
> ---
>
> Hi,
>
> changes on V3:
> - refactor support functions
> - use existing timespec-sub function
>
> changes on V2:
> - Add support functions
>
> support/Makefile | 1 +
> support/support_cpuclock.c | 58 ++++++++++++++++++++++++++++++++++++++
> support/support_cpuclock.h | 28 ++++++++++++++++++
> time/tst-cpuclock1.c | 47 +++++++++++-------------------
> 4 files changed, 103 insertions(+), 31 deletions(-)
> create mode 100644 support/support_cpuclock.c
> create mode 100644 support/support_cpuclock.h
>
> diff --git a/support/Makefile b/support/Makefile
> index a0304e6def..1e45d99b27 100644
> --- a/support/Makefile
> +++ b/support/Makefile
> @@ -31,6 +31,7 @@ libsupport-routines = \
> check_dns_packet \
> check_hostent \
> check_netent \
> + support_cpuclock \
> delayed_exit \
> ignore_stderr \
> next_to_fault \
> diff --git a/support/support_cpuclock.c b/support/support_cpuclock.c
> new file mode 100644
> index 0000000000..cd5212bc32
> --- /dev/null
> +++ b/support/support_cpuclock.c
> @@ -0,0 +1,58 @@
> +/* Support functions for cpuclock tests.
> + 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_cpuclock.h"
> +#include <stdlib.h>
> +#include <assert.h>
> +
> +#define TIMESPEC_HZ 1000000000.0
> +
> +/* Returns t normalized timespec with .tv_nsec < TIMESPEC_HZ
> + and the overflows added to .tv_sec. */
> +struct timespec
> +support_timespec_normalize (struct timespec t)
> +{
> + int diff;
> + diff = (t.tv_nsec / TIMESPEC_HZ);
> + t.tv_sec += diff;
> + t.tv_nsec += -(diff * TIMESPEC_HZ);
> + return t;
> +}
Wouldn't something like:
struct timespec
support_timespec_normalize (struct timespec t)
{
t.tv_sec += (t.tv_nsec / TIMESPEC_HZ);
t.tv_nsec = (t.tv_nsec % TIMESPEC_HZ);
return t;
}
be more straightforward?
Also, since this is a fairly generic function for timespec, I think it
could be added to support/timespec.h, like timespec_add and timespec_sub.
> +
> +/* Returns TRUE if diff to base ratio is within the specified bounds, and
> +FALSE otherwise.
> +For example the call
> +
> +support_timespec_check_ratio(base, diff, 1.2, .5);
> +
> +will check if
> +
> +.5 <= diff/base <= 1.2
> +
> +In other words it will check if diff time is within 50% to 120% of
> +the base time. */
> +int
> +support_timespec_check_ratio (struct timespec base, struct timespec diff,
> + double upper_bound, double lower_bound)
I believe support_timespec_check_in_range (as used somewhere previously
on this thread) or support_timespec_check_within_bounds (maybe too long)
would be more appropriate names, since the ratio is only part of the
calculation, not what the function actually does.
A minor detail, but my brain finds it confusing that the upper_bound
comes before the lower_bound in the arguments list when the final check
will be like: lower_bound <= diff/base <= upper_bound.
At last, diff seems to be a leftover from the current use case for this
function (in time/tst-cpuclock1.c). Since this is a generic function
that can be used in other places, I suggest changing the name to 'value'
(or similar).
> +{
> + assert (upper_bound >= lower_bound);
> + double base_norm = base.tv_sec + base.tv_nsec / TIMESPEC_HZ;
> + double diff_norm = diff.tv_sec + diff.tv_nsec / TIMESPEC_HZ;
> + double ratio = diff_norm / base_norm;
> + return (ratio <= upper_bound && ratio >= lower_bound);
> +}
When Adhermeval suggested to normalize this to nanoseconds instead of
seconds, you replied that this would not be used to check really small
values. But once it enters support/*, I believe it is fair game to be
reused in other places that might as well deal with small values, so
it's something to consider.
> diff --git a/support/support_cpuclock.h b/support/support_cpuclock.h
> new file mode 100644
> index 0000000000..a14bc91e3f
> --- /dev/null
> +++ b/support/support_cpuclock.h
> @@ -0,0 +1,28 @@
> +/* Support functions for cpuclock tests.
> + 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/>. */
> +
> +#ifndef SUPPORT_CPUCLOCK_H
> +#define SUPPORT_CPUCLOCK_H
> +
> +#include <time.h>
> +
> +struct timespec support_timespec_normalize (struct timespec t);
> +int support_timespec_check_ratio (struct timespec base, struct timespec diff,
> + double upper_bound, double lower_bound);
> +
> +#endif /* SUPPORT_CPUCLOCK_H */
> diff --git a/time/tst-cpuclock1.c b/time/tst-cpuclock1.c
> index 0120906f23..72450f71ee 100644
> --- a/time/tst-cpuclock1.c
> +++ b/time/tst-cpuclock1.c
> @@ -26,6 +26,8 @@
> #include <signal.h>
> #include <stdint.h>
> #include <sys/wait.h>
> +#include <support/support_cpuclock.h>
> +#include <support/timespec.h>
>
> /* This function is intended to rack up both user and system time. */
> static void
> @@ -155,19 +157,13 @@ 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)
> + support_timespec_normalize(after);
> + support_timespec_normalize(before);
> + struct timespec diff = timespec_sub(after, before);
> + if (!support_timespec_check_ratio(sleeptime, diff, 1.3, .0025))
> {
> printf ("before - after %ju.%.9ju outside reasonable range\n",
Ok.
> - (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> + (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
Unintended change?
> result = 1;
> }
>
> @@ -194,19 +190,12 @@ 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)
> + support_timespec_normalize(afterns);
> + diff = timespec_sub(afterns, after);
> + if (!support_timespec_check_ratio(sleeptime, diff, 1.6, .71))
> {
> 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;
> }
> }
Ok.
> @@ -241,17 +230,13 @@ do_test (void)
> 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)
> + support_timespec_normalize(dead);
> + diff = timespec_sub(dead, after);
> + sleeptime.tv_nsec = 100000000;
> + if (!support_timespec_check_ratio(sleeptime, diff, 1.6, .7))
> {
Ok.
> printf ("dead - after %ju.%.9ju outside reasonable range\n",
> - (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> + (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
Unintended change?
> result = 1;
> }
>
>
Thanks,
Matheus Castanho
^ permalink raw reply [flat|nested] 44+ messages in thread
* Re: [PATCH v3] Fix time/tst-cpuclock1 intermitent failures
2020-03-04 19:24 ` Matheus Castanho
@ 2020-03-06 17:31 ` Lucas A. M. Magalhaes
0 siblings, 0 replies; 44+ messages in thread
From: Lucas A. M. Magalhaes @ 2020-03-06 17:31 UTC (permalink / raw)
To: Matheus Castanho, libc-alpha
Quoting Matheus Castanho (2020-03-04 16:24:14)
> Hi Lucas,
>
> I believe the main idea behind Carlos' initial suggestion was to make
> something more generic that could also be used in other places. The
> patch is following in this direction alright but I think there are still
> a few details that could be improved in this regard. Comments below.
>
Hi Matheus,
Thanks for the review. AFAIU Carlos was specifically pointing out that this
could be reused on tst-cpuclock2. So, this was my target during the development
of this patch. From what I got you believe that the timespec functions could be
completely generic. I agree so I will rewrite the patch for this.
> > +#include "support_cpuclock.h"
> > +#include <stdlib.h>
> > +#include <assert.h>
> > +
> > +#define TIMESPEC_HZ 1000000000.0
> > +
> > +/* Returns t normalized timespec with .tv_nsec < TIMESPEC_HZ
> > + and the overflows added to .tv_sec. */
> > +struct timespec
> > +support_timespec_normalize (struct timespec t)
> > +{
> > + int diff;
> > + diff = (t.tv_nsec / TIMESPEC_HZ);
> > + t.tv_sec += diff;
> > + t.tv_nsec += -(diff * TIMESPEC_HZ);
> > + return t;
> > +}
>
> Wouldn't something like:
>
> struct timespec
> support_timespec_normalize (struct timespec t)
> {
> t.tv_sec += (t.tv_nsec / TIMESPEC_HZ);
> t.tv_nsec = (t.tv_nsec % TIMESPEC_HZ);
> return t;
> }
>
> be more straightforward?
>
Yes, Nice. Thanks to point this out.
^ permalink raw reply [flat|nested] 44+ messages in thread
* [PATCH v4] Fix time/tst-cpuclock1 intermitent failures
2020-02-20 18:17 ` [PATCH v3] " Lucas A. M. Magalhaes
2020-03-04 19:24 ` Matheus Castanho
@ 2020-03-10 16:20 ` Lucas A. M. Magalhaes
2020-03-10 16:30 ` Andreas Schwab
` (2 more replies)
1 sibling, 3 replies; 44+ messages in thread
From: Lucas A. M. Magalhaes @ 2020-03-10 16:20 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 where relaxed to keep it from fail on this systems.
A refactor of the spent time checking was made with some support
functions. With the advantage to represent time jitter in percent
of the target.
The values used by the test boundaries are all empirical.
---
Hi,
changes on V4:
- move functions to support/timespec.c
- simplify functions
changes on V3:
- refactor support functions
- use existing timespec-sub function
changes on V2:
- Add support functions
---
support/timespec.c | 34 ++++++++++++++++++++++++++++++++
support/timespec.h | 6 ++++++
time/tst-cpuclock1.c | 46 +++++++++++++++-----------------------------
3 files changed, 55 insertions(+), 31 deletions(-)
diff --git a/support/timespec.c b/support/timespec.c
index ea6b947546..babe7801a2 100644
--- a/support/timespec.c
+++ b/support/timespec.c
@@ -19,6 +19,7 @@
#include <support/timespec.h>
#include <stdio.h>
#include <stdint.h>
+#include <assert.h>
void
test_timespec_before_impl (const char *file, int line,
@@ -57,3 +58,36 @@ test_timespec_equal_or_after_impl (const char *file, int line,
(intmax_t) diff.tv_sec, (intmax_t) diff.tv_nsec);
}
}
+
+/* Returns t normalized timespec with .tv_nsec < TIMESPEC_HZ
+ and the overflows added to .tv_sec. */
+struct timespec
+support_timespec_normalize (struct timespec t)
+{
+ t.tv_sec += t.tv_nsec / TIMESPEC_HZ;
+ t.tv_nsec -= t.tv_nsec % TIMESPEC_HZ;
+ return t;
+}
+
+/* Returns TRUE if deviation to base ratio is within the specified bounds, and
+FALSE otherwise.
+For example the call
+
+support_timespec_check_in_range(base, deviation, .5, 1.2);
+
+will check if
+
+.5 <= deviation/base <= 1.2
+
+In other words it will check if deviation time is within 50% to 120% of
+the base time. */
+int
+support_timespec_check_in_range (struct timespec base, struct timespec deviation,
+ double lower_bound, double upper_bound)
+{
+ assert (upper_bound >= lower_bound);
+ long base_norm = base.tv_sec * TIMESPEC_HZ + base.tv_nsec;
+ long deviation_norm = deviation.tv_sec * TIMESPEC_HZ + deviation.tv_nsec;
+ double ratio = (double)deviation_norm / base_norm;
+ return (lower_bound <= ratio && ratio <= upper_bound);
+}
diff --git a/support/timespec.h b/support/timespec.h
index c5852dfe75..98d18663d0 100644
--- a/support/timespec.h
+++ b/support/timespec.h
@@ -48,6 +48,12 @@ void test_timespec_equal_or_after_impl (const char *file, int line,
const struct timespec left,
const struct timespec right);
+struct timespec support_timespec_normalize (struct timespec t);
+
+int support_timespec_check_in_range (struct timespec base, struct timespec deviation,
+ double upper_bound, double lower_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/time/tst-cpuclock1.c b/time/tst-cpuclock1.c
index 0120906f23..0c67a61e0d 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,19 +156,13 @@ 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)
+ support_timespec_normalize(after);
+ support_timespec_normalize(before);
+ struct timespec diff = timespec_sub(after, before);
+ if (!support_timespec_check_in_range(sleeptime, diff, .0025, 1.3))
{
printf ("before - after %ju.%.9ju outside reasonable range\n",
- (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
+ (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
result = 1;
}
@@ -194,19 +189,12 @@ 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)
+ support_timespec_normalize(afterns);
+ diff = timespec_sub(afterns, after);
+ if (!support_timespec_check_in_range(sleeptime, diff, .71, 1.6))
{
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;
}
}
@@ -241,17 +229,13 @@ do_test (void)
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)
+ support_timespec_normalize(dead);
+ diff = timespec_sub(dead, after);
+ sleeptime.tv_nsec = 100000000;
+ if (!support_timespec_check_in_range(sleeptime, diff, .7, 1.6))
{
printf ("dead - after %ju.%.9ju outside reasonable range\n",
- (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
+ (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
result = 1;
}
--
2.20.1
^ permalink raw reply related [flat|nested] 44+ messages in thread
* Re: [PATCH v4] Fix time/tst-cpuclock1 intermitent failures
2020-03-10 16:20 ` [PATCH v4] " Lucas A. M. Magalhaes
@ 2020-03-10 16:30 ` Andreas Schwab
2020-03-10 17:45 ` Carlos O'Donell via Libc-alpha
2020-03-23 17:20 ` [PATCH v5] " Lucas A. M. Magalhaes via Libc-alpha
2 siblings, 0 replies; 44+ messages in thread
From: Andreas Schwab @ 2020-03-10 16:30 UTC (permalink / raw)
To: Lucas A. M. Magalhaes; +Cc: libc-alpha
On Mär 10 2020, Lucas A. M. Magalhaes wrote:
> diff --git a/time/tst-cpuclock1.c b/time/tst-cpuclock1.c
> index 0120906f23..0c67a61e0d 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,19 +156,13 @@ 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)
> + support_timespec_normalize(after);
> + support_timespec_normalize(before);
> + struct timespec diff = timespec_sub(after, before);
> + if (!support_timespec_check_in_range(sleeptime, diff, .0025, 1.3))
Style: space before paren.
Andreas.
--
Andreas Schwab, SUSE Labs, schwab@suse.de
GPG Key fingerprint = 0196 BAD8 1CE9 1970 F4BE 1748 E4D4 88E3 0EEA B9D7
"And now for something completely different."
^ permalink raw reply [flat|nested] 44+ messages in thread
* Re: [PATCH v4] Fix time/tst-cpuclock1 intermitent failures
2020-03-10 16:20 ` [PATCH v4] " Lucas A. M. Magalhaes
2020-03-10 16:30 ` Andreas Schwab
@ 2020-03-10 17:45 ` Carlos O'Donell via Libc-alpha
2020-03-23 17:20 ` [PATCH v5] " Lucas A. M. Magalhaes via Libc-alpha
2 siblings, 0 replies; 44+ messages in thread
From: Carlos O'Donell via Libc-alpha @ 2020-03-10 17:45 UTC (permalink / raw)
To: Lucas A. M. Magalhaes, libc-alpha
On 3/10/20 12:20 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 where relaxed to keep it from fail on this systems.
>
> A refactor of the spent time checking was made with some support
> functions. With the advantage to represent time jitter in percent
> of the target.
>
> The values used by the test boundaries are all empirical.
Getting closer. Still needs some work. See suggestions below for v5.
> ---
>
> Hi,
>
> changes on V4:
> - move functions to support/timespec.c
> - simplify functions
>
> changes on V3:
> - refactor support functions
> - use existing timespec-sub function
>
> changes on V2:
> - Add support functions
> ---
> support/timespec.c | 34 ++++++++++++++++++++++++++++++++
> support/timespec.h | 6 ++++++
> time/tst-cpuclock1.c | 46 +++++++++++++++-----------------------------
> 3 files changed, 55 insertions(+), 31 deletions(-)
>
> diff --git a/support/timespec.c b/support/timespec.c
> index ea6b947546..babe7801a2 100644
> --- a/support/timespec.c
> +++ b/support/timespec.c
> @@ -19,6 +19,7 @@
> #include <support/timespec.h>
> #include <stdio.h>
> #include <stdint.h>
> +#include <assert.h>
OK.
>
> void
> test_timespec_before_impl (const char *file, int line,
> @@ -57,3 +58,36 @@ test_timespec_equal_or_after_impl (const char *file, int line,
> (intmax_t) diff.tv_sec, (intmax_t) diff.tv_nsec);
> }
> }
> +
> +/* Returns t normalized timespec with .tv_nsec < TIMESPEC_HZ
> + and the overflows added to .tv_sec. */
> +struct timespec
> +support_timespec_normalize (struct timespec t)
> +{
> + t.tv_sec += t.tv_nsec / TIMESPEC_HZ;
> + t.tv_nsec -= t.tv_nsec % TIMESPEC_HZ;
(1) This doesn't seem correct.
{ 0, 1000000001 } - initial value
{ 1, 1000000001 } - +1s
{ 1, 1000000000 } - -1ns
Expected:
{ 1, 1}
Suggest:
t.tv_sec += t.tv_nsec / TIMESPEC_HZ;
t.tv_nsec = t.tv_nsec % TIMESPEC_HZ;
See my comment below about test cases.
(2) Don't modify arguments, return modified argument.
> + return t;
> +}
> +
> +/* Returns TRUE if deviation to base ratio is within the specified bounds, and
> +FALSE otherwise.
Suggest:
"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(base, deviation, .5, 1.2);
> +
> +will check if
> +
> +.5 <= deviation/base <= 1.2
> +
> +In other words it will check if deviation time is within 50% to 120% of
> +the base time. */
(3) Use expected and observed everywhere.
I would say "base" is the "expected" value.
I would say "deviation" is the "observed" value.
> +int
> +support_timespec_check_in_range (struct timespec base, struct timespec deviation,
> + double lower_bound, double upper_bound)
> +{
> + assert (upper_bound >= lower_bound);
> + long base_norm = base.tv_sec * TIMESPEC_HZ + base.tv_nsec;
> + long deviation_norm = deviation.tv_sec * TIMESPEC_HZ + deviation.tv_nsec;
> + double ratio = (double)deviation_norm / base_norm;
> + return (lower_bound <= ratio && ratio <= upper_bound);
> +}
(4) Add test cases.
Could you please add a handful of test cases in support/ for this new function?
That way we prove it's working as expected on all systems.
You should test positive and negative times.
You should test times inside the range, outside the range, and exactly on
lower and upper range boundaries.
> diff --git a/support/timespec.h b/support/timespec.h
> index c5852dfe75..98d18663d0 100644
> --- a/support/timespec.h
> +++ b/support/timespec.h
> @@ -48,6 +48,12 @@ void test_timespec_equal_or_after_impl (const char *file, int line,
> const struct timespec left,
> const struct timespec right);
>
> +struct timespec support_timespec_normalize (struct timespec t);
> +
> +int support_timespec_check_in_range (struct timespec base, struct timespec deviation,
> + double upper_bound, double lower_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/time/tst-cpuclock1.c b/time/tst-cpuclock1.c
> index 0120906f23..0c67a61e0d 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,19 +156,13 @@ 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)
> + support_timespec_normalize(after);
> + support_timespec_normalize(before);
> + struct timespec diff = timespec_sub(after, before);
(5) Compose like this with new function that returns new struct.
diff = timespec_sub (support_timespec_normalize (before),
support_timespec_normalize (after));
> + if (!support_timespec_check_in_range(sleeptime, diff, .0025, 1.3))
(6) Need comments explaining magic constants.
> {
> printf ("before - after %ju.%.9ju outside reasonable range\n",
> - (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> + (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> result = 1;
> }
>
> @@ -194,19 +189,12 @@ 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)
> + support_timespec_normalize(afterns);
> + diff = timespec_sub(afterns, after);
(5) Likewise.
> + if (!support_timespec_check_in_range(sleeptime, diff, .71, 1.6))
(6) Likewise.
> {
> 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;
> }
> }
> @@ -241,17 +229,13 @@ do_test (void)
> 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)
> + support_timespec_normalize(dead);
> + diff = timespec_sub(dead, after);
(5) Likewise.
> + sleeptime.tv_nsec = 100000000;
> + if (!support_timespec_check_in_range(sleeptime, diff, .7, 1.6))
(6) Likewise.
> {
> printf ("dead - after %ju.%.9ju outside reasonable range\n",
> - (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> + (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> result = 1;
> }
>
> -- 2.20.1
--
Cheers,
Carlos.
^ permalink raw reply [flat|nested] 44+ messages in thread
* [PATCH v5] Fix time/tst-cpuclock1 intermitent failures
2020-03-10 16:20 ` [PATCH v4] " Lucas A. M. Magalhaes
2020-03-10 16:30 ` Andreas Schwab
2020-03-10 17:45 ` Carlos O'Donell via Libc-alpha
@ 2020-03-23 17:20 ` Lucas A. M. Magalhaes via Libc-alpha
2020-03-23 21:06 ` Carlos O'Donell via Libc-alpha
2020-03-31 11:34 ` [PATCH v6] " Lucas A. M. Magalhaes via Libc-alpha
2 siblings, 2 replies; 44+ messages in thread
From: Lucas A. M. Magalhaes via Libc-alpha @ 2020-03-23 17:20 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.
---
Hi,
changes on V5:
- add tests for support_timespec_check_in_range
- fix support_timespec_normalize
- add comments
- fix style
changes on V4:
- move functions to support/timespec.c
- simplify functions
changes on V3:
- refactor support functions
- use existing timespec-sub function
changes on V2:
- Add support functions
---
support/Makefile | 1 +
support/timespec.c | 36 ++++++++++
support/timespec.h | 6 ++
support/tst-timespec.c | 147 +++++++++++++++++++++++++++++++++++++++++
time/tst-cpuclock1.c | 48 +++++---------
5 files changed, 208 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..53e07566b6 100644
--- a/support/timespec.c
+++ b/support/timespec.c
@@ -19,6 +19,7 @@
#include <support/timespec.h>
#include <stdio.h>
#include <stdint.h>
+#include <assert.h>
void
test_timespec_before_impl (const char *file, int line,
@@ -57,3 +58,38 @@ test_timespec_equal_or_after_impl (const char *file, int line,
(intmax_t) diff.tv_sec, (intmax_t) diff.tv_nsec);
}
}
+
+/* Returns t normalized timespec with .tv_nsec < TIMESPEC_HZ
+ and the overflows added to .tv_sec. */
+struct timespec
+support_timespec_normalize (struct timespec t)
+{
+ struct timespec r;
+ r.tv_sec = t.tv_sec + (t.tv_nsec / TIMESPEC_HZ);
+ r.tv_nsec = t.tv_nsec % TIMESPEC_HZ;
+ return r;
+}
+
+/* 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 = expected.tv_sec * TIMESPEC_HZ + expected.tv_nsec;
+ assert(expected_norm != 0);
+ long observed_norm = observed.tv_sec * TIMESPEC_HZ + observed.tv_nsec;
+ 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..9bd6942957 100644
--- a/support/timespec.h
+++ b/support/timespec.h
@@ -48,6 +48,12 @@ void test_timespec_equal_or_after_impl (const char *file, int line,
const struct timespec left,
const struct timespec right);
+struct timespec support_timespec_normalize (struct timespec t);
+
+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..06d817a421
--- /dev/null
+++ b/support/tst-timespec.c
@@ -0,0 +1,147 @@
+/* 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>
+
+struct timespec_test_case
+{
+ struct timespec expected;
+ struct timespec observed;
+ double upper_bound;
+ double lower_bound;
+ int result;
+};
+
+struct timespec_test_case test_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 = LONG_MAX},
+ .observed = {.tv_sec = LONG_MAX, .tv_nsec = LONG_MAX -1},
+ .upper_bound = 1, .lower_bound = .9, .result = 1,
+ },
+ // 15
+ {.expected = { .tv_sec = LONG_MAX, .tv_nsec = LONG_MAX},
+ .observed = {.tv_sec = LONG_MAX, .tv_nsec = LONG_MAX},
+ .upper_bound = 1, .lower_bound = 1, .result = 1,
+ },
+ // 16
+ {.expected = { .tv_sec = LONG_MAX, .tv_nsec = LONG_MAX},
+ .observed = {.tv_sec = LONG_MIN, .tv_nsec = LONG_MIN},
+ .upper_bound = 1, .lower_bound = 1, .result = 0,
+ },
+ // 17
+ {.expected = { .tv_sec = LONG_MIN, .tv_nsec = LONG_MIN},
+ .observed = {.tv_sec = LONG_MIN, .tv_nsec = LONG_MIN},
+ .upper_bound = 1, .lower_bound = 1, .result = 1,
+ },
+ // 18
+ {.expected = { .tv_sec = LONG_MIN, .tv_nsec = LONG_MIN},
+ .observed = {.tv_sec = LONG_MAX, .tv_nsec = LONG_MAX},
+ .upper_bound = 1, .lower_bound = 1, .result = 0,
+ }
+};
+
+static int
+do_test (void)
+{
+ int i = 0;
+
+ int ntests = sizeof (test_cases) / sizeof (test_cases);
+ for (i = 0; i < ntests; i++)
+ {
+ TEST_COMPARE (support_timespec_check_in_range
+ (test_cases[i].expected, test_cases[i].observed,
+ test_cases[i].lower_bound,
+ test_cases[i].upper_bound), test_cases[i].result);
+ }
+ return 0;
+}
+
+#include <support/test-driver.c>
diff --git a/time/tst-cpuclock1.c b/time/tst-cpuclock1.c
index 0120906f23..fe9bb0a31e 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,11 @@ 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. */
+ struct timespec diff = timespec_sub (support_timespec_normalize (after),
+ support_timespec_normalize (before));
+ if (!support_timespec_check_in_range (sleeptime, diff, .0025, 1.3))
{
printf ("before - after %ju.%.9ju outside reasonable range\n",
(uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
@@ -194,19 +190,14 @@ 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. */
+ diff = timespec_sub (support_timespec_normalize (afterns),
+ support_timespec_normalize (after));
+ if (!support_timespec_check_in_range (sleeptime, diff, .71, 1.6))
{
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 +231,12 @@ 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. */
+ diff = timespec_sub (support_timespec_normalize (dead),
+ support_timespec_normalize (after));
+ sleeptime.tv_nsec = 100000000;
+ if (!support_timespec_check_in_range (sleeptime, diff, .7, 1.6))
{
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 related [flat|nested] 44+ messages in thread
* Re: [PATCH v5] Fix time/tst-cpuclock1 intermitent failures
2020-03-23 17:20 ` [PATCH v5] " Lucas A. M. Magalhaes via Libc-alpha
@ 2020-03-23 21:06 ` Carlos O'Donell via Libc-alpha
2020-03-24 19:42 ` Lucas A. M. Magalhaes via Libc-alpha
2020-03-31 11:34 ` [PATCH v6] " Lucas A. M. Magalhaes via Libc-alpha
1 sibling, 1 reply; 44+ messages in thread
From: Carlos O'Donell via Libc-alpha @ 2020-03-23 21:06 UTC (permalink / raw)
To: Lucas A. M. Magalhaes, libc-alpha
On 3/23/20 1:20 PM, Lucas A. M. Magalhaes via Libc-alpha 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.
Suggestions below.
Looking forward to v6.
> ---
>
> Hi,
>
> changes on V5:
> - add tests for support_timespec_check_in_range
> - fix support_timespec_normalize
> - add comments
> - fix style
>
> changes on V4:
> - move functions to support/timespec.c
> - simplify functions
>
> changes on V3:
> - refactor support functions
> - use existing timespec-sub function
>
> changes on V2:
> - Add support functions
> ---
> support/Makefile | 1 +
> support/timespec.c | 36 ++++++++++
> support/timespec.h | 6 ++
> support/tst-timespec.c | 147 +++++++++++++++++++++++++++++++++++++++++
> time/tst-cpuclock1.c | 48 +++++---------
> 5 files changed, 208 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.
> tst-xreadlink \
> tst-xsigstack \
>
> diff --git a/support/timespec.c b/support/timespec.c
> index ea6b947546..53e07566b6 100644
> --- a/support/timespec.c
> +++ b/support/timespec.c
> @@ -19,6 +19,7 @@
> #include <support/timespec.h>
> #include <stdio.h>
> #include <stdint.h>
> +#include <assert.h>
>
> void
> test_timespec_before_impl (const char *file, int line,
> @@ -57,3 +58,38 @@ test_timespec_equal_or_after_impl (const char *file, int line,
> (intmax_t) diff.tv_sec, (intmax_t) diff.tv_nsec);
> }
> }
> +
> +/* Returns t normalized timespec with .tv_nsec < TIMESPEC_HZ
> + and the overflows added to .tv_sec. */
> +struct timespec
> +support_timespec_normalize (struct timespec t)
Please don't use single variable names. Use "from" or "raw".
> +{
> + struct timespec r;
> + r.tv_sec = t.tv_sec + (t.tv_nsec / TIMESPEC_HZ);
> + r.tv_nsec = t.tv_nsec % TIMESPEC_HZ;
> + return r;
> +}
Likewise "r" could be "cooked" or "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 = expected.tv_sec * TIMESPEC_HZ + expected.tv_nsec;
This can cause overflow/underflow.
Please review timespec_add.
We should set this to a extreme value just like timepsec_add for both overflow/underflow.
> + assert(expected_norm != 0);
Why can't expected_norm be zero?
If you have an abstract timespec you may want to check against that.
I would assert that all values are *positive* and write that into the comments
above.
> + long observed_norm = observed.tv_sec * TIMESPEC_HZ + observed.tv_nsec;
> + 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..9bd6942957 100644
> --- a/support/timespec.h
> +++ b/support/timespec.h
> @@ -48,6 +48,12 @@ void test_timespec_equal_or_after_impl (const char *file, int line,
> const struct timespec left,
> const struct timespec right);
>
> +struct timespec support_timespec_normalize (struct timespec t);
Please avoid single character variable names.
> +
> +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..06d817a421
> --- /dev/null
> +++ b/support/tst-timespec.c
> @@ -0,0 +1,147 @@
> +/* Test for support_timespec_check_in_range function.
OK.
> + 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>
> +
> +struct timespec_test_case
> +{
> + struct timespec expected;
> + struct timespec observed;
> + double upper_bound;
> + double lower_bound;
> + int result;
> +};
> +
> +struct timespec_test_case test_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 = LONG_MAX},
> + .observed = {.tv_sec = LONG_MAX, .tv_nsec = LONG_MAX -1},
> + .upper_bound = 1, .lower_bound = .9, .result = 1,
> + },
> + // 15
> + {.expected = { .tv_sec = LONG_MAX, .tv_nsec = LONG_MAX},
> + .observed = {.tv_sec = LONG_MAX, .tv_nsec = LONG_MAX},
> + .upper_bound = 1, .lower_bound = 1, .result = 1,
> + },
> + // 16
> + {.expected = { .tv_sec = LONG_MAX, .tv_nsec = LONG_MAX},
> + .observed = {.tv_sec = LONG_MIN, .tv_nsec = LONG_MIN},
> + .upper_bound = 1, .lower_bound = 1, .result = 0,
> + },
> + // 17
> + {.expected = { .tv_sec = LONG_MIN, .tv_nsec = LONG_MIN},
> + .observed = {.tv_sec = LONG_MIN, .tv_nsec = LONG_MIN},
> + .upper_bound = 1, .lower_bound = 1, .result = 1,
> + },
> + // 18
> + {.expected = { .tv_sec = LONG_MIN, .tv_nsec = LONG_MIN},
> + .observed = {.tv_sec = LONG_MAX, .tv_nsec = LONG_MAX},
> + .upper_bound = 1, .lower_bound = 1, .result = 0,
> + }
> +};
Several of the tests above would cause overflow in the normalization.
I'll review them more closely in v6.
> +
> +static int
> +do_test (void)
> +{
> + int i = 0;
> +
> + int ntests = sizeof (test_cases) / sizeof (test_cases);
> + for (i = 0; i < ntests; i++)
> + {
> + TEST_COMPARE (support_timespec_check_in_range
> + (test_cases[i].expected, test_cases[i].observed,
> + test_cases[i].lower_bound,
> + test_cases[i].upper_bound), test_cases[i].result);
> + }
> + return 0;
> +}
OK.
> +
> +#include <support/test-driver.c>
> diff --git a/time/tst-cpuclock1.c b/time/tst-cpuclock1.c
> index 0120906f23..fe9bb0a31e 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,11 @@ 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. */
> + struct timespec diff = timespec_sub (support_timespec_normalize (after),
> + support_timespec_normalize (before));
> + if (!support_timespec_check_in_range (sleeptime, diff, .0025, 1.3))
The value of 0.0025 doesn't seem correct, can you please confirm that?
This is supposed to be a 0.5s wait, and wait of 1ms doesn't seem correct.
> {
> printf ("before - after %ju.%.9ju outside reasonable range\n",
> (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> @@ -194,19 +190,14 @@ 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. */
> + diff = timespec_sub (support_timespec_normalize (afterns),
> + support_timespec_normalize (after));
> + if (!support_timespec_check_in_range (sleeptime, diff, .71, 1.6))
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 +231,12 @@ 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. */
> + diff = timespec_sub (support_timespec_normalize (dead),
> + support_timespec_normalize (after));
> + sleeptime.tv_nsec = 100000000;
> + if (!support_timespec_check_in_range (sleeptime, diff, .7, 1.6))
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
* Re: [PATCH v5] Fix time/tst-cpuclock1 intermitent failures
2020-03-23 21:06 ` Carlos O'Donell via Libc-alpha
@ 2020-03-24 19:42 ` Lucas A. M. Magalhaes via Libc-alpha
2020-03-31 18:55 ` Carlos O'Donell via Libc-alpha
0 siblings, 1 reply; 44+ messages in thread
From: Lucas A. M. Magalhaes via Libc-alpha @ 2020-03-24 19:42 UTC (permalink / raw)
To: Carlos O'Donell, libc-alpha
Hi Carlos,
Thanks for the review.
Quoting Carlos O'Donell (2020-03-23 18:06:34)
> On 3/23/20 1:20 PM, Lucas A. M. Magalhaes via Libc-alpha wrote:
> > +
> > +/* 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 = expected.tv_sec * TIMESPEC_HZ + expected.tv_nsec;
>
> This can cause overflow/underflow.
>
> Please review timespec_add.
>
> We should set this to a extreme value just like timepsec_add for both overflow/underflow.
>
> > + assert(expected_norm != 0);
>
> Why can't expected_norm be zero?
>
It can't be zero because of the division below. Do you have any suggestions on
this matter?
> If you have an abstract timespec you may want to check against that.
>
> I would assert that all values are *positive* and write that into the comments
> above.
>
> > + long observed_norm = observed.tv_sec * TIMESPEC_HZ + observed.tv_nsec;
> > + double ratio = (double)observed_norm / expected_norm;
> > + return (lower_bound <= ratio && ratio <= upper_bound);
> > +}
[...]
> > +
> > +#include <support/test-driver.c>
> > diff --git a/time/tst-cpuclock1.c b/time/tst-cpuclock1.c
> > index 0120906f23..fe9bb0a31e 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,11 @@ 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. */
> > + struct timespec diff = timespec_sub (support_timespec_normalize (after),
> > + support_timespec_normalize (before));
> > + if (!support_timespec_check_in_range (sleeptime, diff, .0025, 1.3))
>
> The value of 0.0025 doesn't seem correct, can you please confirm that?
>
I got values as low as 0,0008s for this. But I can be more restrict. The
values lower than 0.1 are less than < 1% of my sample. But these are the ones
bothering during cpu stress.
> This is supposed to be a 0.5s wait, and wait of 1ms doesn't seem correct.
>
---
Lucas A. M. Magalhães
^ permalink raw reply [flat|nested] 44+ messages in thread
* [PATCH v6] Fix time/tst-cpuclock1 intermitent failures
2020-03-23 17:20 ` [PATCH v5] " Lucas A. M. Magalhaes via Libc-alpha
2020-03-23 21:06 ` Carlos O'Donell via Libc-alpha
@ 2020-03-31 11:34 ` Lucas A. M. Magalhaes via Libc-alpha
2020-03-31 19:02 ` Carlos O'Donell via Libc-alpha
2020-04-03 19:24 ` [PATCH v7] " Lucas A. M. Magalhaes via Libc-alpha
1 sibling, 2 replies; 44+ messages in thread
From: Lucas A. M. Magalhaes via Libc-alpha @ 2020-03-31 11:34 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.
---
Hi,
changes on V6:
- add overflow handling
- change variables names
changes on V5:
- add tests for support_timespec_check_in_range
- fix support_timespec_normalize
- add comments
- fix style
changes on V4:
- move functions to support/timespec.c
- simplify functions
changes on V3:
- refactor support functions
- use existing timespec-sub function
changes on V2:
- Add support functions
---
support/Makefile | 1 +
support/timespec.c | 54 +++++++++++++++
support/timespec.h | 6 ++
support/tst-timespec.c | 147 +++++++++++++++++++++++++++++++++++++++++
time/tst-cpuclock1.c | 48 +++++---------
5 files changed, 226 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..0f840c2764 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,55 @@ test_timespec_equal_or_after_impl (const char *file, int line,
(intmax_t) diff.tv_sec, (intmax_t) diff.tv_nsec);
}
}
+
+/* Returns t normalized timespec with .tv_nsec < TIMESPEC_HZ
+ and the overflows added to .tv_sec. It assumes times are
+ positive. */
+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 % TIMESPEC_HZ;
+ return norm;
+}
+
+#define TIMESPEC_SHRINK(time, shrinked) \
+{ \
+ if (INT_MULTIPLY_WRAPV(time.tv_sec, TIMESPEC_HZ, &shrinked)) \
+ { \
+ shrinked = (time.tv_sec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long); \
+ } \
+ if (INT_ADD_WRAPV(shrinked, time.tv_nsec, &shrinked)) \
+ { \
+ shrinked = (time.tv_nsec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long); \
+ } \
+} \
+
+/* 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;
+ TIMESPEC_SHRINK(expected, expected_norm);
+ assert(expected_norm != 0);
+ TIMESPEC_SHRINK(observed, observed_norm);
+ 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..86040627c2 100644
--- a/support/timespec.h
+++ b/support/timespec.h
@@ -48,6 +48,12 @@ void test_timespec_equal_or_after_impl (const char *file, int line,
const struct timespec left,
const struct timespec right);
+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..06d817a421
--- /dev/null
+++ b/support/tst-timespec.c
@@ -0,0 +1,147 @@
+/* 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>
+
+struct timespec_test_case
+{
+ struct timespec expected;
+ struct timespec observed;
+ double upper_bound;
+ double lower_bound;
+ int result;
+};
+
+struct timespec_test_case test_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 = LONG_MAX},
+ .observed = {.tv_sec = LONG_MAX, .tv_nsec = LONG_MAX -1},
+ .upper_bound = 1, .lower_bound = .9, .result = 1,
+ },
+ // 15
+ {.expected = { .tv_sec = LONG_MAX, .tv_nsec = LONG_MAX},
+ .observed = {.tv_sec = LONG_MAX, .tv_nsec = LONG_MAX},
+ .upper_bound = 1, .lower_bound = 1, .result = 1,
+ },
+ // 16
+ {.expected = { .tv_sec = LONG_MAX, .tv_nsec = LONG_MAX},
+ .observed = {.tv_sec = LONG_MIN, .tv_nsec = LONG_MIN},
+ .upper_bound = 1, .lower_bound = 1, .result = 0,
+ },
+ // 17
+ {.expected = { .tv_sec = LONG_MIN, .tv_nsec = LONG_MIN},
+ .observed = {.tv_sec = LONG_MIN, .tv_nsec = LONG_MIN},
+ .upper_bound = 1, .lower_bound = 1, .result = 1,
+ },
+ // 18
+ {.expected = { .tv_sec = LONG_MIN, .tv_nsec = LONG_MIN},
+ .observed = {.tv_sec = LONG_MAX, .tv_nsec = LONG_MAX},
+ .upper_bound = 1, .lower_bound = 1, .result = 0,
+ }
+};
+
+static int
+do_test (void)
+{
+ int i = 0;
+
+ int ntests = sizeof (test_cases) / sizeof (test_cases);
+ for (i = 0; i < ntests; i++)
+ {
+ TEST_COMPARE (support_timespec_check_in_range
+ (test_cases[i].expected, test_cases[i].observed,
+ test_cases[i].lower_bound,
+ test_cases[i].upper_bound), test_cases[i].result);
+ }
+ return 0;
+}
+
+#include <support/test-driver.c>
diff --git a/time/tst-cpuclock1.c b/time/tst-cpuclock1.c
index 0120906f23..fe9bb0a31e 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,11 @@ 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. */
+ struct timespec diff = timespec_sub (support_timespec_normalize (after),
+ support_timespec_normalize (before));
+ if (!support_timespec_check_in_range (sleeptime, diff, .0025, 1.3))
{
printf ("before - after %ju.%.9ju outside reasonable range\n",
(uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
@@ -194,19 +190,14 @@ 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. */
+ diff = timespec_sub (support_timespec_normalize (afterns),
+ support_timespec_normalize (after));
+ if (!support_timespec_check_in_range (sleeptime, diff, .71, 1.6))
{
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 +231,12 @@ 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. */
+ diff = timespec_sub (support_timespec_normalize (dead),
+ support_timespec_normalize (after));
+ sleeptime.tv_nsec = 100000000;
+ if (!support_timespec_check_in_range (sleeptime, diff, .7, 1.6))
{
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 related [flat|nested] 44+ messages in thread
* Re: [PATCH v5] Fix time/tst-cpuclock1 intermitent failures
2020-03-24 19:42 ` Lucas A. M. Magalhaes via Libc-alpha
@ 2020-03-31 18:55 ` Carlos O'Donell via Libc-alpha
0 siblings, 0 replies; 44+ messages in thread
From: Carlos O'Donell via Libc-alpha @ 2020-03-31 18:55 UTC (permalink / raw)
To: Lucas A. M. Magalhaes, libc-alpha
On 3/24/20 3:42 PM, Lucas A. M. Magalhaes wrote:
> Hi Carlos,
>
> Thanks for the review.
>
> Quoting Carlos O'Donell (2020-03-23 18:06:34)
>> On 3/23/20 1:20 PM, Lucas A. M. Magalhaes via Libc-alpha wrote:
>>> +
>>> +/* 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 = expected.tv_sec * TIMESPEC_HZ + expected.tv_nsec;
>>
>> This can cause overflow/underflow.
>>
>> Please review timespec_add.
>>
>> We should set this to a extreme value just like timepsec_add for both overflow/underflow.
>>
>>> + assert(expected_norm != 0);
>>
>> Why can't expected_norm be zero?
>>
>
> It can't be zero because of the division below. Do you have any suggestions on
> this matter?
Please add a comment explaining why.
>> If you have an abstract timespec you may want to check against that.
>>
>> I would assert that all values are *positive* and write that into the comments
>> above.
>>
>>> + long observed_norm = observed.tv_sec * TIMESPEC_HZ + observed.tv_nsec;
>>> + double ratio = (double)observed_norm / expected_norm;
>>> + return (lower_bound <= ratio && ratio <= upper_bound);
>>> +}
>
> [...]
>
>>> +
>>> +#include <support/test-driver.c>
>>> diff --git a/time/tst-cpuclock1.c b/time/tst-cpuclock1.c
>>> index 0120906f23..fe9bb0a31e 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,11 @@ 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. */
>>> + struct timespec diff = timespec_sub (support_timespec_normalize (after),
>>> + support_timespec_normalize (before));
>>> + if (!support_timespec_check_in_range (sleeptime, diff, .0025, 1.3))
>>
>> The value of 0.0025 doesn't seem correct, can you please confirm that?
>>
>
> I got values as low as 0,0008s for this. But I can be more restrict. The
> values lower than 0.1 are less than < 1% of my sample. But these are the ones
> bothering during cpu stress.
These *have* to be kernel bugs, and we should not paper over kernel bugs. We should
still fail if the kernel has bugs otherwise we'll never get them fixed upstream.
We should make tests robust with respect to waiting for infinite events to happen.
For example when sleeping we are guaranteed to sleep at-least a certain
amount, and our check should be flexible that we slept at least that amount and
then some amount more, to take into account system load.
In summary: We are making the test robust against system load, not against kernel
defects (which should show up).
--
Cheers,
Carlos.
^ permalink raw reply [flat|nested] 44+ messages in thread
* Re: [PATCH v6] Fix time/tst-cpuclock1 intermitent failures
2020-03-31 11:34 ` [PATCH v6] " Lucas A. M. Magalhaes via Libc-alpha
@ 2020-03-31 19:02 ` Carlos O'Donell via Libc-alpha
2020-04-03 19:24 ` [PATCH v7] " Lucas A. M. Magalhaes via Libc-alpha
1 sibling, 0 replies; 44+ messages in thread
From: Carlos O'Donell via Libc-alpha @ 2020-03-31 19:02 UTC (permalink / raw)
To: Lucas A. M. Magalhaes, libc-alpha
On 3/31/20 7:34 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.
Comments below.
> ---
>
> Hi,
>
> changes on V6:
> - add overflow handling
> - change variables names
>
> changes on V5:
> - add tests for support_timespec_check_in_range
> - fix support_timespec_normalize
> - add comments
> - fix style
>
> changes on V4:
> - move functions to support/timespec.c
> - simplify functions
>
> changes on V3:
> - refactor support functions
> - use existing timespec-sub function
>
> changes on V2:
> - Add support functions
> ---
> support/Makefile | 1 +
> support/timespec.c | 54 +++++++++++++++
> support/timespec.h | 6 ++
> support/tst-timespec.c | 147 +++++++++++++++++++++++++++++++++++++++++
> time/tst-cpuclock1.c | 48 +++++---------
> 5 files changed, 226 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..0f840c2764 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,55 @@ test_timespec_equal_or_after_impl (const char *file, int line,
> (intmax_t) diff.tv_sec, (intmax_t) diff.tv_nsec);
> }
> }
> +
> +/* Returns t normalized timespec with .tv_nsec < TIMESPEC_HZ
> + and the overflows added to .tv_sec. It assumes times are
> + positive. */
> +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 % TIMESPEC_HZ;
> + return norm;
> +}
> +
> +#define TIMESPEC_SHRINK(time, shrinked) \
> +{ \
> + if (INT_MULTIPLY_WRAPV(time.tv_sec, TIMESPEC_HZ, &shrinked)) \
> + { \
> + shrinked = (time.tv_sec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long); \
> + } \
> + if (INT_ADD_WRAPV(shrinked, time.tv_nsec, &shrinked)) \
> + { \
> + shrinked = (time.tv_nsec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long); \
> + } \
> +} \
> +
> +/* 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;
> + TIMESPEC_SHRINK(expected, expected_norm);
Add /* Don't divide by zero. */
> + assert(expected_norm != 0);
> + TIMESPEC_SHRINK(observed, observed_norm);
> + 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..86040627c2 100644
> --- a/support/timespec.h
> +++ b/support/timespec.h
> @@ -48,6 +48,12 @@ void test_timespec_equal_or_after_impl (const char *file, int line,
> const struct timespec left,
> const struct timespec right);
>
> +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..06d817a421
> --- /dev/null
> +++ b/support/tst-timespec.c
> @@ -0,0 +1,147 @@
> +/* 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>
> +
> +struct timespec_test_case
> +{
> + struct timespec expected;
> + struct timespec observed;
> + double upper_bound;
> + double lower_bound;
> + int result;
> +};
> +
> +struct timespec_test_case test_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 = LONG_MAX},
> + .observed = {.tv_sec = LONG_MAX, .tv_nsec = LONG_MAX -1},
> + .upper_bound = 1, .lower_bound = .9, .result = 1,
> + },
> + // 15
> + {.expected = { .tv_sec = LONG_MAX, .tv_nsec = LONG_MAX},
> + .observed = {.tv_sec = LONG_MAX, .tv_nsec = LONG_MAX},
> + .upper_bound = 1, .lower_bound = 1, .result = 1,
> + },
> + // 16
> + {.expected = { .tv_sec = LONG_MAX, .tv_nsec = LONG_MAX},
> + .observed = {.tv_sec = LONG_MIN, .tv_nsec = LONG_MIN},
> + .upper_bound = 1, .lower_bound = 1, .result = 0,
> + },
> + // 17
> + {.expected = { .tv_sec = LONG_MIN, .tv_nsec = LONG_MIN},
> + .observed = {.tv_sec = LONG_MIN, .tv_nsec = LONG_MIN},
> + .upper_bound = 1, .lower_bound = 1, .result = 1,
> + },
> + // 18
> + {.expected = { .tv_sec = LONG_MIN, .tv_nsec = LONG_MIN},
> + .observed = {.tv_sec = LONG_MAX, .tv_nsec = LONG_MAX},
> + .upper_bound = 1, .lower_bound = 1, .result = 0,
> + }
> +};
> +
> +static int
> +do_test (void)
> +{
> + int i = 0;
> +
> + int ntests = sizeof (test_cases) / sizeof (test_cases);
> + for (i = 0; i < ntests; i++)
> + {
> + TEST_COMPARE (support_timespec_check_in_range
> + (test_cases[i].expected, test_cases[i].observed,
> + test_cases[i].lower_bound,
> + test_cases[i].upper_bound), test_cases[i].result);
> + }
> + return 0;
> +}
> +
> +#include <support/test-driver.c>
> diff --git a/time/tst-cpuclock1.c b/time/tst-cpuclock1.c
> index 0120906f23..fe9bb0a31e 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,11 @@ 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. */
> + struct timespec diff = timespec_sub (support_timespec_normalize (after),
> + support_timespec_normalize (before));
> + if (!support_timespec_check_in_range (sleeptime, diff, .0025, 1.3))
The 0.0025 is way too low.
Lets be objective about this.
Can you make these bounds the 90% percentile of the samples you have?
> {
> printf ("before - after %ju.%.9ju outside reasonable range\n",
> (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> @@ -194,19 +190,14 @@ 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. */
> + diff = timespec_sub (support_timespec_normalize (afterns),
> + support_timespec_normalize (after));
> + if (!support_timespec_check_in_range (sleeptime, diff, .71, 1.6))
Likewise.
> {
> 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 +231,12 @@ 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. */
> + diff = timespec_sub (support_timespec_normalize (dead),
> + support_timespec_normalize (after));
> + sleeptime.tv_nsec = 100000000;
> + if (!support_timespec_check_in_range (sleeptime, diff, .7, 1.6))
Likewise.
> {
> 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 v7] Fix time/tst-cpuclock1 intermitent failures
2020-03-31 11:34 ` [PATCH v6] " Lucas A. M. Magalhaes via Libc-alpha
2020-03-31 19:02 ` Carlos O'Donell via Libc-alpha
@ 2020-04-03 19:24 ` Lucas A. M. Magalhaes via Libc-alpha
2020-04-03 20:48 ` Carlos O'Donell via Libc-alpha
2020-04-07 13:59 ` [PATCH v8] " Lucas A. M. Magalhaes via Libc-alpha
1 sibling, 2 replies; 44+ messages in thread
From: Lucas A. M. Magalhaes via Libc-alpha @ 2020-04-03 19:24 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.
---
Hi,
changes on V7:
- change expecting boundaries
- add comments
changes on V6:
- add overflow handling
- change variables names
changes on V5:
- add tests for support_timespec_check_in_range
- fix support_timespec_normalize
- add comments
- fix style
changes on V4:
- move functions to support/timespec.c
- simplify functions
changes on V3:
- refactor support functions
- use existing timespec-sub function
changes on V2:
- Add support functions
---
support/Makefile | 1 +
support/timespec.c | 55 +++++++++++++++
support/timespec.h | 6 ++
support/tst-timespec.c | 147 +++++++++++++++++++++++++++++++++++++++++
time/tst-cpuclock1.c | 48 +++++---------
5 files changed, 227 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..f6b3f87bb1 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,56 @@ test_timespec_equal_or_after_impl (const char *file, int line,
(intmax_t) diff.tv_sec, (intmax_t) diff.tv_nsec);
}
}
+
+/* Returns t normalized timespec with .tv_nsec < TIMESPEC_HZ
+ and the overflows added to .tv_sec. It assumes times are
+ positive. */
+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 % TIMESPEC_HZ;
+ return norm;
+}
+
+#define TIMESPEC_SHRINK(time, shrinked) \
+{ \
+ if (INT_MULTIPLY_WRAPV(time.tv_sec, TIMESPEC_HZ, &shrinked)) \
+ { \
+ shrinked = (time.tv_sec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long); \
+ } \
+ if (INT_ADD_WRAPV(shrinked, time.tv_nsec, &shrinked)) \
+ { \
+ shrinked = (time.tv_nsec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long); \
+ } \
+} \
+
+/* 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;
+ TIMESPEC_SHRINK(expected, expected_norm);
+ /* Don't divide by zero */
+ assert(expected_norm != 0);
+ TIMESPEC_SHRINK(observed, observed_norm);
+ 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..86040627c2 100644
--- a/support/timespec.h
+++ b/support/timespec.h
@@ -48,6 +48,12 @@ void test_timespec_equal_or_after_impl (const char *file, int line,
const struct timespec left,
const struct timespec right);
+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..06d817a421
--- /dev/null
+++ b/support/tst-timespec.c
@@ -0,0 +1,147 @@
+/* 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>
+
+struct timespec_test_case
+{
+ struct timespec expected;
+ struct timespec observed;
+ double upper_bound;
+ double lower_bound;
+ int result;
+};
+
+struct timespec_test_case test_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 = LONG_MAX},
+ .observed = {.tv_sec = LONG_MAX, .tv_nsec = LONG_MAX -1},
+ .upper_bound = 1, .lower_bound = .9, .result = 1,
+ },
+ // 15
+ {.expected = { .tv_sec = LONG_MAX, .tv_nsec = LONG_MAX},
+ .observed = {.tv_sec = LONG_MAX, .tv_nsec = LONG_MAX},
+ .upper_bound = 1, .lower_bound = 1, .result = 1,
+ },
+ // 16
+ {.expected = { .tv_sec = LONG_MAX, .tv_nsec = LONG_MAX},
+ .observed = {.tv_sec = LONG_MIN, .tv_nsec = LONG_MIN},
+ .upper_bound = 1, .lower_bound = 1, .result = 0,
+ },
+ // 17
+ {.expected = { .tv_sec = LONG_MIN, .tv_nsec = LONG_MIN},
+ .observed = {.tv_sec = LONG_MIN, .tv_nsec = LONG_MIN},
+ .upper_bound = 1, .lower_bound = 1, .result = 1,
+ },
+ // 18
+ {.expected = { .tv_sec = LONG_MIN, .tv_nsec = LONG_MIN},
+ .observed = {.tv_sec = LONG_MAX, .tv_nsec = LONG_MAX},
+ .upper_bound = 1, .lower_bound = 1, .result = 0,
+ }
+};
+
+static int
+do_test (void)
+{
+ int i = 0;
+
+ int ntests = sizeof (test_cases) / sizeof (test_cases);
+ for (i = 0; i < ntests; i++)
+ {
+ TEST_COMPARE (support_timespec_check_in_range
+ (test_cases[i].expected, test_cases[i].observed,
+ test_cases[i].lower_bound,
+ test_cases[i].upper_bound), test_cases[i].result);
+ }
+ return 0;
+}
+
+#include <support/test-driver.c>
diff --git a/time/tst-cpuclock1.c b/time/tst-cpuclock1.c
index 0120906f23..f9eb054f89 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,11 @@ 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. */
+ struct timespec diff = timespec_sub (support_timespec_normalize (after),
+ support_timespec_normalize (before));
+ if (!support_timespec_check_in_range (sleeptime, diff, .4, 1.1))
{
printf ("before - after %ju.%.9ju outside reasonable range\n",
(uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
@@ -194,19 +190,14 @@ 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. */
+ 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 +231,12 @@ 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. */
+ 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 related [flat|nested] 44+ messages in thread
* Re: [PATCH v7] Fix time/tst-cpuclock1 intermitent failures
2020-04-03 19:24 ` [PATCH v7] " Lucas A. M. Magalhaes via Libc-alpha
@ 2020-04-03 20:48 ` Carlos O'Donell via Libc-alpha
2020-04-07 13:59 ` [PATCH v8] " Lucas A. M. Magalhaes via Libc-alpha
1 sibling, 0 replies; 44+ messages in thread
From: Carlos O'Donell via Libc-alpha @ 2020-04-03 20:48 UTC (permalink / raw)
To: Lucas A. M. Magalhaes, libc-alpha
On 4/3/20 3:24 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.
>
Looking forward to v8. I think we're almost done. If you fixup the
TIMESPEC_SHRINK interface (static inline API moved to support with
a few testes) then it's good to checkin next time.
Thank you for your patience!
> ---
>
> Hi,
>
> changes on V7:
> - change expecting boundaries
> - add comments
>
> changes on V6:
> - add overflow handling
> - change variables names
>
> changes on V5:
> - add tests for support_timespec_check_in_range
> - fix support_timespec_normalize
> - add comments
> - fix style
>
> changes on V4:
> - move functions to support/timespec.c
> - simplify functions
>
> changes on V3:
> - refactor support functions
> - use existing timespec-sub function
>
> changes on V2:
> - Add support functions
> ---
> support/Makefile | 1 +
> support/timespec.c | 55 +++++++++++++++
> support/timespec.h | 6 ++
> support/tst-timespec.c | 147 +++++++++++++++++++++++++++++++++++++++++
> time/tst-cpuclock1.c | 48 +++++---------
> 5 files changed, 227 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.
> tst-xreadlink \
> tst-xsigstack \
>
> diff --git a/support/timespec.c b/support/timespec.c
> index ea6b947546..f6b3f87bb1 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,56 @@ test_timespec_equal_or_after_impl (const char *file, int line,
> (intmax_t) diff.tv_sec, (intmax_t) diff.tv_nsec);
> }
> }
> +
> +/* Returns t normalized timespec with .tv_nsec < TIMESPEC_HZ
> + and the overflows added to .tv_sec. It assumes times are
> + positive. */
> +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. Overflow sets max value, while underflow sets min value (will look for those tests).
> + }
> + norm.tv_nsec = time.tv_nsec % TIMESPEC_HZ;
OK.
> + return norm;
> +}
> +
Needs comment:
/* Convert TIME to nanoseconds stored in shrinked. */
> +#define TIMESPEC_SHRINK(time, shrinked) \
(1) The name should indicate what it does.
Shink isn't quite what we're doing here.
We're converting struct timespec to ns.
Plese call this timespec_ns(time), and make it a static inline
that returns the converted long value.
(2) Choose static inlines over macros.
Macros are hard to debug and we get better diagnostics with static inlines,
please prefer them over macros.
(3) Implement pure functions over functions that mutate arguments.
Also from a design perspective it's better to create interfaces that take
const input, produce a value, and return that value in an immutable result.
This way the caller controls the manner in which the store is carried out.
The function is therefore pure and you know it has no side-effects
on the parameters. Pure functions are easier to debug, reason about,
combine, and parallelize :-)
For example:
expected_norm = timespec_ns (time);
Then you do this:
> +{ \
long ns;
> + if (INT_MULTIPLY_WRAPV(time.tv_sec, TIMESPEC_HZ, &shrinked)) \
> + { \
> + shrinked = (time.tv_sec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long); \
> + } \
> + if (INT_ADD_WRAPV(shrinked, time.tv_nsec, &shrinked)) \
> + { \
> + shrinked = (time.tv_nsec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long); > + } \
/* Return the converted ns value. */
return ns;
> +} \
Can you move this generic routine out of this test now and into support/timespec.h?
This function needs tests to verify the behaviour of the edge cases
(including overflow and underflow). You can put the tests into the
same new test if you like because they are related.
> +
> +/* 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;
> + TIMESPEC_SHRINK(expected, expected_norm);
expected_norm = timespec_ns (expected);
> + /* Don't divide by zero */
> + assert(expected_norm != 0);
> + TIMESPEC_SHRINK(observed, observed_norm);
Likewise.
> + 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..86040627c2 100644
> --- a/support/timespec.h
> +++ b/support/timespec.h
> @@ -48,6 +48,12 @@ void test_timespec_equal_or_after_impl (const char *file, int line,
> const struct timespec left,
> const struct timespec right);
>
> +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..06d817a421
> --- /dev/null
> +++ b/support/tst-timespec.c
> @@ -0,0 +1,147 @@
> +/* Test for support_timespec_check_in_range function.
OK.
> + 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>
> +
> +struct timespec_test_case
> +{
> + struct timespec expected;
> + struct timespec observed;
> + double upper_bound;
> + double lower_bound;
> + int result;
> +};
> +
> +struct timespec_test_case test_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 = LONG_MAX},
> + .observed = {.tv_sec = LONG_MAX, .tv_nsec = LONG_MAX -1},
> + .upper_bound = 1, .lower_bound = .9, .result = 1,
> + },
> + // 15
> + {.expected = { .tv_sec = LONG_MAX, .tv_nsec = LONG_MAX},
> + .observed = {.tv_sec = LONG_MAX, .tv_nsec = LONG_MAX},
> + .upper_bound = 1, .lower_bound = 1, .result = 1,
> + },
> + // 16
> + {.expected = { .tv_sec = LONG_MAX, .tv_nsec = LONG_MAX},
> + .observed = {.tv_sec = LONG_MIN, .tv_nsec = LONG_MIN},
> + .upper_bound = 1, .lower_bound = 1, .result = 0,
> + },
> + // 17
> + {.expected = { .tv_sec = LONG_MIN, .tv_nsec = LONG_MIN},
> + .observed = {.tv_sec = LONG_MIN, .tv_nsec = LONG_MIN},
> + .upper_bound = 1, .lower_bound = 1, .result = 1,
> + },
> + // 18
> + {.expected = { .tv_sec = LONG_MIN, .tv_nsec = LONG_MIN},
> + .observed = {.tv_sec = LONG_MAX, .tv_nsec = LONG_MAX},
> + .upper_bound = 1, .lower_bound = 1, .result = 0,
> + }
> +};
> +
> +static int
> +do_test (void)
> +{
> + int i = 0;
> +
> + int ntests = sizeof (test_cases) / sizeof (test_cases);
> + for (i = 0; i < ntests; i++)
> + {
> + TEST_COMPARE (support_timespec_check_in_range
> + (test_cases[i].expected, test_cases[i].observed,
> + test_cases[i].lower_bound,
> + test_cases[i].upper_bound), test_cases[i].result);
> + }
> + return 0;
> +}
OK.
> +
> +#include <support/test-driver.c>
> diff --git a/time/tst-cpuclock1.c b/time/tst-cpuclock1.c
> index 0120906f23..f9eb054f89 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>
OK.
>
> /* This function is intended to rack up both user and system time. */
> static void
> @@ -155,16 +156,11 @@ 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. */
> + struct timespec diff = timespec_sub (support_timespec_normalize (after),
> + support_timespec_normalize (before));
> + if (!support_timespec_check_in_range (sleeptime, diff, .4, 1.1))
OK.
> {
> printf ("before - after %ju.%.9ju outside reasonable range\n",
> (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
> @@ -194,19 +190,14 @@ 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. */
> + 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 +231,12 @@ 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. */
> + 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 v8] Fix time/tst-cpuclock1 intermitent failures
2020-04-03 19:24 ` [PATCH v7] " Lucas A. M. Magalhaes via Libc-alpha
2020-04-03 20:48 ` Carlos O'Donell via Libc-alpha
@ 2020-04-07 13:59 ` Lucas A. M. Magalhaes via Libc-alpha
2020-04-21 17:44 ` [PATCH v9] " Lucas A. M. Magalhaes via Libc-alpha
1 sibling, 1 reply; 44+ messages in thread
From: Lucas A. M. Magalhaes via Libc-alpha @ 2020-04-07 13:59 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.
---
Hi Carlos,
Thanks for the work and patience on this reviews.
changes on V8:
Add support_timespec_ns
Add more tests
changes on V7:
- change expecting boundaries
- add comments
changes on V6:
- add overflow handling
- change variables names
changes on V5:
- add tests for support_timespec_check_in_range
- fix support_timespec_normalize
- add comments
- fix style
changes on V4:
- move functions to support/timespec.c
- simplify functions
changes on V3:
- refactor support functions
- use existing timespec-sub function
changes on V2:
- Add support functions
---
support/Makefile | 1 +
support/timespec.c | 59 ++++++++++
support/timespec.h | 8 ++
support/tst-timespec.c | 241 +++++++++++++++++++++++++++++++++++++++++
time/tst-cpuclock1.c | 48 +++-----
5 files changed, 327 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..156a409733 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,60 @@ 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. */
+long
+support_timespec_ns (struct timespec time)
+{
+ long time_ns;
+ if (INT_MULTIPLY_WRAPV(time.tv_sec, TIMESPEC_HZ, &time_ns))
+ {
+ time_ns = (time.tv_sec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long);
+ }
+ if (INT_ADD_WRAPV(time_ns, time.tv_nsec, &time_ns))
+ {
+ time_ns = (time.tv_nsec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long);
+ }
+ return time_ns;
+}
+
+/* Returns t normalized timespec with .tv_nsec < TIMESPEC_HZ
+ and the overflows added to .tv_sec. It assumes times are
+ positive. */
+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 % 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..e9f21e6e35
--- /dev/null
+++ b/support/tst-timespec.c
@@ -0,0 +1,241 @@
+/* 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>
+
+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 = 1000000000,
+ },
+ {.time = {.tv_sec = 1, .tv_nsec = 1},
+ .time_ns = 1000000001,
+ },
+ {.time = {.tv_sec = 0, .tv_nsec = -1},
+ .time_ns = -1,
+ },
+ {.time = {.tv_sec = -1, .tv_nsec = 0},
+ .time_ns = -1000000000,
+ },
+ {.time = {.tv_sec = -1, .tv_nsec = -1},
+ .time_ns = -1000000001,
+ },
+ {.time = {.tv_sec = 1, .tv_nsec = -1},
+ .time_ns = 999999999,
+ },
+ {.time = {.tv_sec = -1, .tv_nsec = 1},
+ .time_ns = -999999999,
+ },
+ {.time = {.tv_sec = LONG_MAX, .tv_nsec = 1},
+ .time_ns = LONG_MAX,
+ },
+ {.time = {.tv_sec = LONG_MIN, .tv_nsec = -1},
+ .time_ns = LONG_MIN,
+ }
+};
+
+/* Test cases for timespec_norm */
+struct timespec_norm_test_case norm_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 = 10000000000},
+ .norm = {.tv_sec = 1, .tv_nsec = 0}
+ },
+ {.time = {.tv_sec = 0, .tv_nsec = 10000000001},
+ .norm = {.tv_sec = 1, .tv_nsec =1}
+ },
+ {.time = {.tv_sec = 1, .tv_nsec = 10000000000},
+ .norm = {.tv_sec = 2, .tv_nsec = 0}
+ },
+ {.time = {.tv_sec = 1, .tv_nsec = 10000000001},
+ .norm = {.tv_sec = 1, .tv_nsec = 1}
+ },
+ {.time = {.tv_sec = LONG_MAX, .tv_nsec = 1000000000},
+ .norm = {.tv_sec = LONG_MAX, .tv_nsec = 0},
+ }
+};
+
+/* 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 = LONG_MAX},
+ .observed = {.tv_sec = LONG_MAX, .tv_nsec = LONG_MAX -1},
+ .upper_bound = 1, .lower_bound = .9, .result = 1,
+ },
+ // 15
+ {.expected = { .tv_sec = LONG_MAX, .tv_nsec = LONG_MAX},
+ .observed = {.tv_sec = LONG_MAX, .tv_nsec = LONG_MAX},
+ .upper_bound = 1, .lower_bound = 1, .result = 1,
+ },
+ // 16
+ {.expected = { .tv_sec = LONG_MAX, .tv_nsec = LONG_MAX},
+ .observed = {.tv_sec = LONG_MIN, .tv_nsec = LONG_MIN},
+ .upper_bound = 1, .lower_bound = 1, .result = 0,
+ },
+ // 17
+ {.expected = { .tv_sec = LONG_MIN, .tv_nsec = LONG_MIN},
+ .observed = {.tv_sec = LONG_MIN, .tv_nsec = LONG_MIN},
+ .upper_bound = 1, .lower_bound = 1, .result = 1,
+ },
+ // 18
+ {.expected = { .tv_sec = LONG_MIN, .tv_nsec = LONG_MIN},
+ .observed = {.tv_sec = LONG_MAX, .tv_nsec = LONG_MAX},
+ .upper_bound = 1, .lower_bound = 1, .result = 0,
+ }
+};
+
+static int
+do_test (void)
+{
+ int i = 0;
+ int ntests = sizeof (ns_cases) / sizeof (ns_cases);
+
+ 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);
+ struct timespec result;
+ 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);
+ for (i = 0; i < ntests; 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..f9eb054f89 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,11 @@ 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. */
+ struct timespec diff = timespec_sub (support_timespec_normalize (after),
+ support_timespec_normalize (before));
+ if (!support_timespec_check_in_range (sleeptime, diff, .4, 1.1))
{
printf ("before - after %ju.%.9ju outside reasonable range\n",
(uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec);
@@ -194,19 +190,14 @@ 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. */
+ 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 +231,12 @@ 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. */
+ 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 related [flat|nested] 44+ messages in thread
* [PATCH v9] Fix time/tst-cpuclock1 intermitent failures
2020-04-07 13:59 ` [PATCH v8] " Lucas A. M. Magalhaes via Libc-alpha
@ 2020-04-21 17:44 ` Lucas A. M. Magalhaes via Libc-alpha
2020-05-11 17:41 ` Lucas A. M. Magalhaes via Libc-alpha
` (2 more replies)
0 siblings, 3 replies; 44+ messages in thread
From: Lucas A. M. Magalhaes via Libc-alpha @ 2020-04-21 17:44 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.
---
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 related [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-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 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
* 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
end of thread, other threads:[~2020-07-15 19:45 UTC | newest]
Thread overview: 44+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2020-02-06 14:48 [PATCH v2] Fix time/tst-cpuclock1 intermitent failures Lucas A. M. Magalhaes
2020-02-17 16:44 ` Lucas A. M. Magalhaes
2020-02-18 12:44 ` Adhemerval Zanella
2020-02-19 16:42 ` Lucas A. M. Magalhaes
2020-02-19 18:51 ` Adhemerval Zanella
2020-02-20 18:17 ` [PATCH v3] " Lucas A. M. Magalhaes
2020-03-04 19:24 ` Matheus Castanho
2020-03-06 17:31 ` Lucas A. M. Magalhaes
2020-03-10 16:20 ` [PATCH v4] " Lucas A. M. Magalhaes
2020-03-10 16:30 ` Andreas Schwab
2020-03-10 17:45 ` Carlos O'Donell via Libc-alpha
2020-03-23 17:20 ` [PATCH v5] " Lucas A. M. Magalhaes via Libc-alpha
2020-03-23 21:06 ` Carlos O'Donell via Libc-alpha
2020-03-24 19:42 ` Lucas A. M. Magalhaes via Libc-alpha
2020-03-31 18:55 ` Carlos O'Donell via Libc-alpha
2020-03-31 11:34 ` [PATCH v6] " Lucas A. M. Magalhaes via Libc-alpha
2020-03-31 19:02 ` Carlos O'Donell via Libc-alpha
2020-04-03 19:24 ` [PATCH v7] " Lucas A. M. Magalhaes via Libc-alpha
2020-04-03 20:48 ` Carlos O'Donell via Libc-alpha
2020-04-07 13:59 ` [PATCH v8] " Lucas A. M. Magalhaes via Libc-alpha
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 13:58 ` 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
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
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
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
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
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
2020-07-15 19:44 ` H.J. Lu via Libc-alpha
2020-07-14 13:08 ` Lucas A. M. Magalhaes via Libc-alpha
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).