[PATCH v2] Fix time/tst-cpuclock1 intermitent failures

classic Classic list List threaded Threaded
25 messages Options
12
Reply | Threaded
Open this post in threaded view
|

[PATCH v2] Fix time/tst-cpuclock1 intermitent failures

Lucas A. M. Magalhaes
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

Reply | Threaded
Open this post in threaded view
|

Re: [PATCH v2] Fix time/tst-cpuclock1 intermitent failures

Lucas A. M. Magalhaes
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
>
Reply | Threaded
Open this post in threaded view
|

Re: [PATCH v2] Fix time/tst-cpuclock1 intermitent failures

Adhemerval Zanella-2
In reply to this post by Lucas A. M. Magalhaes


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;
>
Reply | Threaded
Open this post in threaded view
|

Re: [PATCH v2] Fix time/tst-cpuclock1 intermitent failures

Lucas A. M. Magalhaes
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;
> >
Reply | Threaded
Open this post in threaded view
|

Re: [PATCH v2] Fix time/tst-cpuclock1 intermitent failures

Adhemerval Zanella-2


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;
>>>
Reply | Threaded
Open this post in threaded view
|

[PATCH v3] Fix time/tst-cpuclock1 intermitent failures

Lucas A. M. Magalhaes
In reply to this post by Lucas A. M. Magalhaes
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

Reply | Threaded
Open this post in threaded view
|

Re: [PATCH v3] Fix time/tst-cpuclock1 intermitent failures

Matheus Castanho
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
Reply | Threaded
Open this post in threaded view
|

Re: [PATCH v3] Fix time/tst-cpuclock1 intermitent failures

Lucas A. M. Magalhaes
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.
Reply | Threaded
Open this post in threaded view
|

[PATCH v4] Fix time/tst-cpuclock1 intermitent failures

Lucas A. M. Magalhaes
In reply to this post by Lucas A. M. Magalhaes
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

Reply | Threaded
Open this post in threaded view
|

Re: [PATCH v4] Fix time/tst-cpuclock1 intermitent failures

Andreas Schwab
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, [hidden email]
GPG Key fingerprint = 0196 BAD8 1CE9 1970 F4BE  1748 E4D4 88E3 0EEA B9D7
"And now for something completely different."
Reply | Threaded
Open this post in threaded view
|

Re: [PATCH v4] Fix time/tst-cpuclock1 intermitent failures

Sourceware - libc-alpha mailing list
In reply to this post by Lucas A. M. Magalhaes
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.

Reply | Threaded
Open this post in threaded view
|

[PATCH v5] Fix time/tst-cpuclock1 intermitent failures

Sourceware - libc-alpha mailing list
In reply to this post by Lucas A. M. Magalhaes
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

Reply | Threaded
Open this post in threaded view
|

Re: [PATCH v5] Fix time/tst-cpuclock1 intermitent failures

Sourceware - libc-alpha mailing list
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.

Reply | Threaded
Open this post in threaded view
|

Re: [PATCH v5] Fix time/tst-cpuclock1 intermitent failures

Sourceware - libc-alpha mailing list
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
Reply | Threaded
Open this post in threaded view
|

[PATCH v6] Fix time/tst-cpuclock1 intermitent failures

Sourceware - libc-alpha mailing list
In reply to this post by Sourceware - libc-alpha mailing list
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

Reply | Threaded
Open this post in threaded view
|

Re: [PATCH v5] Fix time/tst-cpuclock1 intermitent failures

Sourceware - libc-alpha mailing list
In reply to this post by Sourceware - libc-alpha mailing list
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.

Reply | Threaded
Open this post in threaded view
|

Re: [PATCH v6] Fix time/tst-cpuclock1 intermitent failures

Sourceware - libc-alpha mailing list
In reply to this post by Sourceware - libc-alpha mailing list
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.

Reply | Threaded
Open this post in threaded view
|

[PATCH v7] Fix time/tst-cpuclock1 intermitent failures

Sourceware - libc-alpha mailing list
In reply to this post by Sourceware - libc-alpha mailing list
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

Reply | Threaded
Open this post in threaded view
|

Re: [PATCH v7] Fix time/tst-cpuclock1 intermitent failures

Sourceware - libc-alpha mailing list
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.

Reply | Threaded
Open this post in threaded view
|

[PATCH v8] Fix time/tst-cpuclock1 intermitent failures

Sourceware - libc-alpha mailing list
In reply to this post by Sourceware - libc-alpha mailing list
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

12