From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mx0b-001b2d01.pphosted.com (mx0b-001b2d01.pphosted.com [148.163.158.5]) by sourceware.org (Postfix) with ESMTPS id D024F3851C16 for ; Thu, 25 Jun 2020 17:26:24 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.3.2 sourceware.org D024F3851C16 Received: from pps.filterd (m0098417.ppops.net [127.0.0.1]) by mx0a-001b2d01.pphosted.com (8.16.0.42/8.16.0.42) with SMTP id 05PH2aPJ062536 for ; Thu, 25 Jun 2020 13:26:24 -0400 Received: from pps.reinject (localhost [127.0.0.1]) by mx0a-001b2d01.pphosted.com with ESMTP id 31uwyj9fdc-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT) for ; Thu, 25 Jun 2020 13:26:24 -0400 Received: from m0098417.ppops.net (m0098417.ppops.net [127.0.0.1]) by pps.reinject (8.16.0.36/8.16.0.36) with SMTP id 05PH2i8W063328 for ; Thu, 25 Jun 2020 13:26:23 -0400 Received: from ppma02wdc.us.ibm.com (aa.5b.37a9.ip4.static.sl-reverse.com [169.55.91.170]) by mx0a-001b2d01.pphosted.com with ESMTP id 31uwyj9fcy-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Thu, 25 Jun 2020 13:26:23 -0400 Received: from pps.filterd (ppma02wdc.us.ibm.com [127.0.0.1]) by ppma02wdc.us.ibm.com (8.16.0.42/8.16.0.42) with SMTP id 05PHAXwp001096; Thu, 25 Jun 2020 17:26:23 GMT Received: from b03cxnp08028.gho.boulder.ibm.com (b03cxnp08028.gho.boulder.ibm.com [9.17.130.20]) by ppma02wdc.us.ibm.com with ESMTP id 31uus3wr59-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Thu, 25 Jun 2020 17:26:23 +0000 Received: from b03ledav006.gho.boulder.ibm.com (b03ledav006.gho.boulder.ibm.com [9.17.130.237]) by b03cxnp08028.gho.boulder.ibm.com (8.14.9/8.14.9/NCO v10.0) with ESMTP id 05PHQMW923855446 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Thu, 25 Jun 2020 17:26:22 GMT Received: from b03ledav006.gho.boulder.ibm.com (unknown [127.0.0.1]) by IMSVA (Postfix) with ESMTP id 25C46C6057; Thu, 25 Jun 2020 17:26:22 +0000 (GMT) Received: from b03ledav006.gho.boulder.ibm.com (unknown [127.0.0.1]) by IMSVA (Postfix) with ESMTP id 8A11EC6055; Thu, 25 Jun 2020 17:26:21 +0000 (GMT) Received: from localhost (unknown [9.163.59.160]) by b03ledav006.gho.boulder.ibm.com (Postfix) with ESMTP; Thu, 25 Jun 2020 17:26:21 +0000 (GMT) Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable In-Reply-To: <20200612152817.1347220-1-lamm@linux.ibm.com> References: <20200421174456.28663-1-lamm@linux.ibm.com> <20200612152817.1347220-1-lamm@linux.ibm.com> Subject: Re: [PATCH v10] Fix time/tst-cpuclock1 intermitent failures From: "Lucas A. M. Magalhaes" To: libc-alpha@sourceware.org Date: Thu, 25 Jun 2020 14:26:20 -0300 Message-ID: <159310598033.1139437.17090595691549678135@localhost.localdomain> User-Agent: alot/0.9.1 X-TM-AS-GCONF: 00 X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:6.0.216, 18.0.687 definitions=2020-06-25_12:2020-06-25, 2020-06-25 signatures=0 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 cotscore=-2147483648 spamscore=0 phishscore=0 suspectscore=0 bulkscore=0 impostorscore=0 mlxscore=0 mlxlogscore=999 lowpriorityscore=0 malwarescore=0 adultscore=0 clxscore=1015 priorityscore=1501 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2004280000 definitions=main-2006250104 X-Spam-Status: No, score=-13.7 required=5.0 tests=BAYES_00, GIT_PATCH_0, KAM_DMARC_STATUS, KAM_SHORT, RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_H2, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.2 X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on server2.sourceware.org X-BeenThere: libc-alpha@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Libc-alpha mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Thu, 25 Jun 2020 17:26:27 -0000 Ping Quoting Lucas A. M. Magalhaes via Libc-alpha (2020-06-12 12:28:17) > This test fails intermittently in systems with heavy load as > CLOCK_PROCESS_CPUTIME_ID is subject to scheduler pressure. Thus the > test boundaries were relaxed to keep it from failing on such systems. >=20 > 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. >=20 > The values used by the test boundaries are all empirical. >=20 > --- >=20 > changes on V10: > Change comments >=20 > changes on V9: > Add new testcases > Fix support/tst-timespec do_run > Add comments > Change boundaries >=20 > changes on V8: > Add support_timespec_ns > Add more tests >=20 > This list of changes where getting to long. > --- > support/Makefile | 1 + > support/timespec.c | 64 +++++++++ > support/timespec.h | 8 ++ > support/tst-timespec.c | 320 +++++++++++++++++++++++++++++++++++++++++ > time/tst-cpuclock1.c | 52 +++---- > 5 files changed, 415 insertions(+), 30 deletions(-) > create mode 100644 support/tst-timespec.c >=20 > diff --git a/support/Makefile b/support/Makefile > index 51484310cd..914242d866 100644 > --- a/support/Makefile > +++ b/support/Makefile > @@ -236,6 +236,7 @@ tests =3D \ > tst-test_compare \ > tst-test_compare_blob \ > tst-test_compare_string \ > + tst-timespec \ > tst-xreadlink \ > tst-xsigstack \ > =20 > diff --git a/support/timespec.c b/support/timespec.c > index ea6b947546..9f5449e49e 100644 > --- a/support/timespec.c > +++ b/support/timespec.c > @@ -19,6 +19,8 @@ > #include > #include > #include > +#include > +#include > =20 > void > test_timespec_before_impl (const char *file, int line, > @@ -57,3 +59,65 @@ test_timespec_equal_or_after_impl (const char *file, i= nt line, > (intmax_t) diff.tv_sec, (intmax_t) diff.tv_nsec); > } > } > + > +/* Convert TIME to nanoseconds stored in a long. > + Returns long maximum or minimum if the conversion overflows > + or underflows, respectively. */ > +long > +support_timespec_ns (struct timespec time) > +{ > + long time_ns; > + if (INT_MULTIPLY_WRAPV(time.tv_sec, TIMESPEC_HZ, &time_ns)) > + { > + return (time.tv_sec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long); > + } > + if (INT_ADD_WRAPV(time_ns, time.tv_nsec, &time_ns)) > + { > + return (time.tv_nsec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long); > + } > + return time_ns; > +} > + > +/* Returns time normalized timespec with .tv_nsec < TIMESPEC_HZ > + and the whole seconds added to .tv_sec. If an overflow or > + underflow occurs the values are clamped to its maximum or > + minimum respectively. */ > +struct timespec > +support_timespec_normalize (struct timespec time) > +{ > + struct timespec norm; > + if (INT_ADD_WRAPV (time.tv_sec, (time.tv_nsec / TIMESPEC_HZ), &norm.tv= _sec)) > + { > + norm.tv_sec =3D (time.tv_nsec < 0) ? TYPE_MINIMUM (time_t): TYPE_MA= XIMUM (time_t); > + norm.tv_nsec =3D (time.tv_nsec < 0) ? -1 * (TIMESPEC_HZ - 1) : TIME= SPEC_HZ - 1; > + return norm; > + } > + norm.tv_nsec =3D time.tv_nsec % TIMESPEC_HZ; > + return norm; > +} > + > +/* Returns TRUE if the observed time is within the given percentage > + bounds of the expected time, and FALSE otherwise. > + For example the call > + > + support_timespec_check_in_range(expected, observed, 0.5, 1.2); > + > + will check if > + > + 0.5 of expected <=3D observed <=3D 1.2 of expected > + > + In other words it will check if observed time is within 50% to > + 120% of the expected time. */ > +int > +support_timespec_check_in_range (struct timespec expected, struct timesp= ec observed, > + double lower_bound, double upper_bound) > +{ > + assert (upper_bound >=3D lower_bound); > + long expected_norm, observed_norm; > + expected_norm =3D support_timespec_ns (expected); > + /* Don't divide by zero */ > + assert(expected_norm !=3D 0); > + observed_norm =3D support_timespec_ns (observed); > + double ratio =3D (double)observed_norm / expected_norm; > + return (lower_bound <=3D ratio && ratio <=3D 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 *fi= le, int line, > const struct timespec left, > const struct timespec right); > =20 > +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 ti= mespec observed, > + double lower_bound, double upper_bound); > + > + > /* Check that the timespec on the left represents a time before the > time on the right. */ > #define TEST_TIMESPEC_BEFORE(left, right) \ > diff --git a/support/tst-timespec.c b/support/tst-timespec.c > new file mode 100644 > index 0000000000..71423555a9 > --- /dev/null > +++ b/support/tst-timespec.c > @@ -0,0 +1,320 @@ > +/* Test for support_timespec_check_in_range function. > + Copyright (C) 2020 Free Software Foundation, Inc. > + This file is part of the GNU C Library. > + > + The GNU C Library is free software; you can redistribute it and/or > + modify it under the terms of the GNU Lesser General Public > + License as published by the Free Software Foundation; either > + version 2.1 of the License, or (at your option) any later version. > + > + The GNU C Library is distributed in the hope that it will be useful, > + but WITHOUT ANY WARRANTY; without even the implied warranty of > + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU > + Lesser General Public License for more details. > + > + You should have received a copy of the GNU Lesser General Public > + License along with the GNU C Library; if not, see > + . */ > + > +#include > +#include > +#include > + > +#define TIMESPEC_HZ 1000000000 > + > +struct timespec_ns_test_case > +{ > + struct timespec time; > + long time_ns; > +}; > + > +struct timespec_norm_test_case > +{ > + struct timespec time; > + struct timespec norm; > +}; > + > +struct timespec_test_case > +{ > + struct timespec expected; > + struct timespec observed; > + double upper_bound; > + double lower_bound; > + int result; > +}; > + > +/* Test cases for timespec_ns */ > +struct timespec_ns_test_case ns_cases[] =3D { > + {.time =3D {.tv_sec =3D 0, .tv_nsec =3D 0}, > + .time_ns =3D 0, > + }, > + {.time =3D {.tv_sec =3D 0, .tv_nsec =3D 1}, > + .time_ns =3D 1, > + }, > + {.time =3D {.tv_sec =3D 1, .tv_nsec =3D 0}, > + .time_ns =3D TIMESPEC_HZ, > + }, > + {.time =3D {.tv_sec =3D 1, .tv_nsec =3D 1}, > + .time_ns =3D TIMESPEC_HZ + 1, > + }, > + {.time =3D {.tv_sec =3D 0, .tv_nsec =3D -1}, > + .time_ns =3D -1, > + }, > + {.time =3D {.tv_sec =3D -1, .tv_nsec =3D 0}, > + .time_ns =3D -TIMESPEC_HZ, > + }, > + {.time =3D {.tv_sec =3D -1, .tv_nsec =3D -1}, > + .time_ns =3D -TIMESPEC_HZ - 1, > + }, > + {.time =3D {.tv_sec =3D 1, .tv_nsec =3D -1}, > + .time_ns =3D TIMESPEC_HZ - 1, > + }, > + {.time =3D {.tv_sec =3D -1, .tv_nsec =3D 1}, > + .time_ns =3D -TIMESPEC_HZ + 1, > + }, > + /* Overflow bondary by 2 */ > + {.time =3D {.tv_sec =3D LONG_MAX / TIMESPEC_HZ, .tv_nsec =3D LONG_MAX%= TIMESPEC_HZ - 1}, > + .time_ns =3D LONG_MAX - 1, > + }, > + /* Overflow bondary */ > + {.time =3D {.tv_sec =3D LONG_MAX / TIMESPEC_HZ, .tv_nsec =3D LONG_MAX%= TIMESPEC_HZ}, > + .time_ns =3D LONG_MAX, > + }, > + /* Underflow bondary by 1 */ > + {.time =3D {.tv_sec =3D LONG_MIN / TIMESPEC_HZ, .tv_nsec =3D LONG_MIN%= TIMESPEC_HZ + 1}, > + .time_ns =3D LONG_MIN + 1, > + }, > + /* Underflow bondary */ > + {.time =3D {.tv_sec =3D LONG_MIN / TIMESPEC_HZ, .tv_nsec =3D LONG_MIN%= TIMESPEC_HZ}, > + .time_ns =3D LONG_MIN, > + }, > + /* Multiplication overflow */ > + {.time =3D {.tv_sec =3D LONG_MAX / TIMESPEC_HZ + 1, .tv_nsec =3D 1}, > + .time_ns =3D LONG_MAX, > + }, > + /* Multiplication underflow */ > + {.time =3D {.tv_sec =3D LONG_MIN / TIMESPEC_HZ - 1, .tv_nsec =3D -1}, > + .time_ns =3D LONG_MIN, > + }, > + /* Sum overflows */ > + {.time =3D {.tv_sec =3D LONG_MAX / TIMESPEC_HZ, .tv_nsec =3D LONG_MAX%= TIMESPEC_HZ + 1}, > + .time_ns =3D LONG_MAX, > + }, > + /* Sum underflow */ > + {.time =3D {.tv_sec =3D LONG_MIN / TIMESPEC_HZ, .tv_nsec =3D LONG_MIN%= TIMESPEC_HZ - 1}, > + .time_ns =3D LONG_MIN, > + } > +}; > + > +/* Test cases for timespec_norm */ > +struct timespec_norm_test_case norm_cases[] =3D { > + /* Positive cases */ > + {.time =3D {.tv_sec =3D 0, .tv_nsec =3D 0}, > + .norm =3D {.tv_sec =3D 0, .tv_nsec =3D 0} > + }, > + {.time =3D {.tv_sec =3D 1, .tv_nsec =3D 0}, > + .norm =3D {.tv_sec =3D 1, .tv_nsec =3D 0} > + }, > + {.time =3D {.tv_sec =3D 0, .tv_nsec =3D 1}, > + .norm =3D {.tv_sec =3D 0, .tv_nsec =3D 1} > + }, > + {.time =3D {.tv_sec =3D 0, .tv_nsec =3D TIMESPEC_HZ}, > + .norm =3D {.tv_sec =3D 1, .tv_nsec =3D 0} > + }, > + {.time =3D {.tv_sec =3D 0, .tv_nsec =3D TIMESPEC_HZ + 1}, > + .norm =3D {.tv_sec =3D 1, .tv_nsec =3D 1} > + }, > + {.time =3D {.tv_sec =3D 1, .tv_nsec =3D TIMESPEC_HZ}, > + .norm =3D {.tv_sec =3D 2, .tv_nsec =3D 0} > + }, > + {.time =3D {.tv_sec =3D 1, .tv_nsec =3D TIMESPEC_HZ + 1}, > + .norm =3D {.tv_sec =3D 2, .tv_nsec =3D 1} > + }, > + /* Negative cases */ > + {.time =3D {.tv_sec =3D 0, .tv_nsec =3D -TIMESPEC_HZ}, > + .norm =3D {.tv_sec =3D -1, .tv_nsec =3D 0} > + }, > + {.time =3D {.tv_sec =3D 0, .tv_nsec =3D -TIMESPEC_HZ - 1}, > + .norm =3D {.tv_sec =3D -1, .tv_nsec =3D -1} > + }, > + {.time =3D {.tv_sec =3D -1, .tv_nsec =3D -TIMESPEC_HZ}, > + .norm =3D {.tv_sec =3D -2, .tv_nsec =3D 0} > + }, > + {.time =3D {.tv_sec =3D -1, .tv_nsec =3D -TIMESPEC_HZ - 1}, > + .norm =3D {.tv_sec =3D -2, .tv_nsec =3D -1} > + }, > + /* Overflow bondary by 2 */ > + {.time =3D {.tv_sec =3D LONG_MAX - 2, .tv_nsec =3D TIMESPEC_HZ + 1}, > + .norm =3D {.tv_sec =3D LONG_MAX - 1, 1}, > + }, > + /* Overflow bondary by 1 */ > + {.time =3D {.tv_sec =3D LONG_MAX - 1, .tv_nsec =3D TIMESPEC_HZ + 1}, > + .norm =3D {.tv_sec =3D LONG_MAX, .tv_nsec =3D 1}, > + }, > + /* Underflow bondary by 2 */ > + {.time =3D {.tv_sec =3D LONG_MIN + 2, .tv_nsec =3D -TIMESPEC_HZ - 1}, > + .norm =3D {.tv_sec =3D LONG_MIN + 1, -1}, > + }, > + /* Underflow bondary by 1 */ > + {.time =3D {.tv_sec =3D LONG_MIN + 1, .tv_nsec =3D -TIMESPEC_HZ - 1}, > + .norm =3D {.tv_sec =3D LONG_MIN, .tv_nsec =3D -1}, > + }, > + /* SUM overflow */ > + {.time =3D {.tv_sec =3D LONG_MAX, .tv_nsec =3D TIMESPEC_HZ}, > + .norm =3D {.tv_sec =3D LONG_MAX, .tv_nsec =3D TIMESPEC_HZ - 1}, > + }, > + /* SUM underflow */ > + {.time =3D {.tv_sec =3D LONG_MIN, .tv_nsec =3D -TIMESPEC_HZ}, > + .norm =3D {.tv_sec =3D LONG_MIN, .tv_nsec =3D -1 * (TIMESPEC_HZ - 1)}, > + } > +}; > + > +/* Test cases for timespec_check_in_range */ > +struct timespec_test_case check_cases[] =3D { > + /* 0 - In range */ > + {.expected =3D {.tv_sec =3D 1, .tv_nsec =3D 0}, > + .observed =3D {.tv_sec =3D 1, .tv_nsec =3D 0}, > + .upper_bound =3D 1, .lower_bound =3D 1, .result =3D 1, > + }, > + /* 1 - Out of range */ > + {.expected =3D {.tv_sec =3D 1, .tv_nsec =3D 0}, > + .observed =3D {.tv_sec =3D 2, .tv_nsec =3D 0}, > + .upper_bound =3D 1, .lower_bound =3D 1, .result =3D 0, > + }, > + /* 2 - Upper Bound */ > + {.expected =3D {.tv_sec =3D 1, .tv_nsec =3D 0}, > + .observed =3D {.tv_sec =3D 2, .tv_nsec =3D 0}, > + .upper_bound =3D 2, .lower_bound =3D 1, .result =3D 1, > + }, > + /* 3 - Lower Bound */ > + {.expected =3D {.tv_sec =3D 1, .tv_nsec =3D 0}, > + .observed =3D {.tv_sec =3D 0, .tv_nsec =3D 0}, > + .upper_bound =3D 1, .lower_bound =3D 0, .result =3D 1, > + }, > + /* 4 - Out of range by nanosecs */ > + {.expected =3D {.tv_sec =3D 1, .tv_nsec =3D 0}, > + .observed =3D {.tv_sec =3D 1, .tv_nsec =3D 500}, > + .upper_bound =3D 1, .lower_bound =3D 1, .result =3D 0, > + }, > + /* 5 - In range by nanosecs */ > + {.expected =3D {.tv_sec =3D 1, .tv_nsec =3D 0}, > + .observed =3D {.tv_sec =3D 1, .tv_nsec =3D 50000}, > + .upper_bound =3D 1.3, .lower_bound =3D 1, .result =3D 1, > + }, > + /* 6 - Big nanosecs */ > + {.expected =3D {.tv_sec =3D 1, .tv_nsec =3D 0}, > + .observed =3D {.tv_sec =3D 0, .tv_nsec =3D 4000000}, > + .upper_bound =3D 1, .lower_bound =3D .001, .result =3D 1, > + }, > + /* 7 - In range Negative values */ > + {.expected =3D {.tv_sec =3D -1, .tv_nsec =3D 0}, > + .observed =3D {.tv_sec =3D -1, .tv_nsec =3D 0}, > + .upper_bound =3D 1, .lower_bound =3D 1, .result =3D 1, > + }, > + /* 8 - Out of range Negative values */ > + {.expected =3D {.tv_sec =3D -1, .tv_nsec =3D 0}, > + .observed =3D {.tv_sec =3D -1, .tv_nsec =3D 0}, > + .upper_bound =3D -1, .lower_bound =3D -1, .result =3D 0, > + }, > + /* 9 - Negative values with negative nanosecs */ > + {.expected =3D {.tv_sec =3D -1, .tv_nsec =3D 0}, > + .observed =3D {.tv_sec =3D -1, .tv_nsec =3D -2000}, > + .upper_bound =3D 1, .lower_bound =3D 1, .result =3D 0, > + }, > + /* 10 - Strict bounds */ > + {.expected =3D {.tv_sec =3D -1, .tv_nsec =3D 0}, > + .observed =3D {.tv_sec =3D -1, .tv_nsec =3D -20000}, > + .upper_bound =3D 1.00002, .lower_bound =3D 1.0000191, .result =3D 1, > + }, > + /* 11 - Strict bounds with loose upper bound */ > + {.expected =3D {.tv_sec =3D 1, .tv_nsec =3D 20000}, > + .observed =3D {.tv_sec =3D 1, .tv_nsec =3D 30000}, > + .upper_bound =3D 1.0000100000, .lower_bound =3D 1.0000099998, .result= =3D 1, > + }, > + /* 12 - Strict bounds with loose lower bound */ > + {.expected =3D {.tv_sec =3D 1, .tv_nsec =3D 20000}, > + .observed =3D {.tv_sec =3D 1, .tv_nsec =3D 30000}, > + .upper_bound =3D 1.0000099999, .lower_bound =3D 1.00000999979, .resul= t =3D 1, > + }, > + /* 13 - Strict bounds highest precision */ > + {.expected =3D {.tv_sec =3D 1, .tv_nsec =3D 20000}, > + .observed =3D {.tv_sec =3D 1, .tv_nsec =3D 30000}, > + .upper_bound =3D 1.00000999980001, .lower_bound =3D 1.00000999979999,= .result =3D 1, > + }, > + /* Maximum/Minimum long values */ > + /* 14 */ > + {.expected =3D {.tv_sec =3D LONG_MAX, .tv_nsec =3D TIMESPEC_HZ - 1}, > + .observed =3D {.tv_sec =3D LONG_MAX, .tv_nsec =3D TIMESPEC_HZ - 2}, > + .upper_bound =3D 1, .lower_bound =3D .9, .result =3D 1, > + }, > + /* 15 - support_timespec_ns overflow */ > + {.expected =3D {.tv_sec =3D LONG_MAX, .tv_nsec =3D TIMESPEC_HZ}, > + .observed =3D {.tv_sec =3D LONG_MAX, .tv_nsec =3D TIMESPEC_HZ}, > + .upper_bound =3D 1, .lower_bound =3D 1, .result =3D 1, > + }, > + /* 16 - support_timespec_ns overflow + underflow */ > + {.expected =3D {.tv_sec =3D LONG_MAX, .tv_nsec =3D TIMESPEC_HZ}, > + .observed =3D {.tv_sec =3D LONG_MIN, .tv_nsec =3D -TIMESPEC_HZ}, > + .upper_bound =3D 1, .lower_bound =3D 1, .result =3D 0, > + }, > + /* 17 - support_timespec_ns underflow */ > + {.expected =3D {.tv_sec =3D LONG_MIN, .tv_nsec =3D -TIMESPEC_HZ}, > + .observed =3D {.tv_sec =3D LONG_MIN, .tv_nsec =3D -TIMESPEC_HZ}, > + .upper_bound =3D 1, .lower_bound =3D 1, .result =3D 1, > + }, > + /* 18 - support_timespec_ns underflow + overflow */ > + {.expected =3D {.tv_sec =3D LONG_MIN, .tv_nsec =3D -TIMESPEC_HZ}, > + .observed =3D {.tv_sec =3D LONG_MAX, .tv_nsec =3D TIMESPEC_HZ}, > + .upper_bound =3D 1, .lower_bound =3D 1, .result =3D 0, > + }, > + /* 19 - Biggest division */ > + {.expected =3D {.tv_sec =3D LONG_MAX / TIMESPEC_HZ , .tv_nsec =3D TIME= SPEC_HZ - 1}, > + .observed =3D {.tv_sec =3D 0, .tv_nsec =3D 1}, > + .upper_bound =3D 1, .lower_bound =3D 1.0842021724855044e-19, .result = =3D 1, > + }, > + /* 20 - Lowest division */ > + {.expected =3D {.tv_sec =3D 0, .tv_nsec =3D 1}, > + .observed =3D {.tv_sec =3D LONG_MAX / TIMESPEC_HZ , .tv_nsec =3D TIME= SPEC_HZ - 1}, > + .upper_bound =3D LONG_MAX, .lower_bound =3D 1, .result =3D 1, > + }, > +}; > + > +static int > +do_test (void) > +{ > + int i =3D 0; > + int ntests =3D sizeof (ns_cases) / sizeof (ns_cases[0]); > + > + printf("Testing support_timespec_ns\n"); > + for (i =3D 0; i < ntests; i++) > + { > + TEST_COMPARE (support_timespec_ns (ns_cases[i].time), > + ns_cases[i].time_ns); > + } > + > + ntests =3D sizeof (norm_cases) / sizeof (norm_cases[0]); > + struct timespec result; > + printf("Testing support_timespec_normalize\n"); > + for (i =3D 0; i < ntests; i++) > + { > + result =3D 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 =3D sizeof (check_cases) / sizeof (check_cases[0]); > + printf("Testing support_timespec_check_in_range\n"); > + for (i =3D 0; i < ntests; i++) > + { > + /* Its hard to find which test failed with just the TEST_COMPARE r= eport. > + So here we print every running testcase as well. */ > + printf("Test case %d\n", i); > + TEST_COMPARE (support_timespec_check_in_range > + (check_cases[i].expected, check_cases[i].observed, > + check_cases[i].lower_bound, > + check_cases[i].upper_bound), check_cases[i].result); > + } > + return 0; > +} > + > +#include > diff --git a/time/tst-cpuclock1.c b/time/tst-cpuclock1.c > index 0120906f23..1ac611a92b 100644 > --- a/time/tst-cpuclock1.c > +++ b/time/tst-cpuclock1.c > @@ -26,6 +26,7 @@ > #include > #include > #include > +#include > =20 > /* This function is intended to rack up both user and system time. */ > static void > @@ -155,16 +156,12 @@ do_test (void) > printf ("live PID %d after sleep =3D> %ju.%.9ju\n", > child, (uintmax_t) after.tv_sec, (uintmax_t) after.tv_nsec); > =20 > - struct timespec diff =3D { .tv_sec =3D after.tv_sec - before.tv_sec, > - .tv_nsec =3D after.tv_nsec - before.tv_nsec }; > - if (diff.tv_nsec < 0) > - { > - --diff.tv_sec; > - diff.tv_nsec +=3D 1000000000; > - } > - if (diff.tv_sec !=3D 0 > - || diff.tv_nsec > 600000000 > - || diff.tv_nsec < 100000000) > + /* The bound values are empirically defined by testing this code over = high cpu > + usage and different nice values. Of all the values we keep the 90th > + percentile of values and use those values for our testing allowed r= ange. */ > + struct timespec diff =3D timespec_sub (support_timespec_normalize (aft= er), > + support_timespec_normalize (before= )); > + if (!support_timespec_check_in_range (sleeptime, diff, .9, 1.1)) > { > printf ("before - after %ju.%.9ju outside reasonable range\n", > (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec); > @@ -194,19 +191,16 @@ do_test (void) > } > else > { > - struct timespec d =3D { .tv_sec =3D afterns.tv_sec - after.tv_s= ec, > - .tv_nsec =3D afterns.tv_nsec - after.tv_n= sec }; > - if (d.tv_nsec < 0) > - { > - --d.tv_sec; > - d.tv_nsec +=3D 1000000000; > - } > - if (d.tv_sec > 0 > - || d.tv_nsec < sleeptime.tv_nsec > - || d.tv_nsec > sleeptime.tv_nsec * 2) > + /* The bound values are empirically defined by testing this code= over > + high cpu usage and different nice values. Of all the values w= e keep > + the 90th percentile of values and use those values for our te= sting > + allowed range. */ > + diff =3D 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 =3D 1; > } > } > @@ -240,15 +234,13 @@ do_test (void) > /* Should be close to 0.6. */ > printf ("dead PID %d =3D> %ju.%.9ju\n", > child, (uintmax_t) dead.tv_sec, (uintmax_t) dead.tv_nsec); > - > - diff.tv_sec =3D dead.tv_sec - after.tv_sec; > - diff.tv_nsec =3D dead.tv_nsec - after.tv_nsec; > - if (diff.tv_nsec < 0) > - { > - --diff.tv_sec; > - diff.tv_nsec +=3D 1000000000; > - } > - if (diff.tv_sec !=3D 0 || diff.tv_nsec > 200000000) > + /* The bound values are empirically defined by testing this code over = high cpu > + usage and different nice values. Of all the values we keep the 90th > + percentile of values and use those values for our testing allowed r= ange. */ > + diff =3D timespec_sub (support_timespec_normalize (dead), > + support_timespec_normalize (after)); > + sleeptime.tv_nsec =3D 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); > --=20 > 2.26.2 >