From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mx0a-001b2d01.pphosted.com (mx0a-001b2d01.pphosted.com [148.163.156.1]) by sourceware.org (Postfix) with ESMTPS id 0749B3840C1E for ; Mon, 25 May 2020 11:46:55 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.3.2 sourceware.org 0749B3840C1E Received: from pps.filterd (m0098409.ppops.net [127.0.0.1]) by mx0a-001b2d01.pphosted.com (8.16.0.42/8.16.0.42) with SMTP id 04PBVeL2033097 for ; Mon, 25 May 2020 07:46:55 -0400 Received: from pps.reinject (localhost [127.0.0.1]) by mx0a-001b2d01.pphosted.com with ESMTP id 316y4tbwm4-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT) for ; Mon, 25 May 2020 07:46:54 -0400 Received: from m0098409.ppops.net (m0098409.ppops.net [127.0.0.1]) by pps.reinject (8.16.0.36/8.16.0.36) with SMTP id 04PBWGSY034562 for ; Mon, 25 May 2020 07:46:54 -0400 Received: from ppma04wdc.us.ibm.com (1a.90.2fa9.ip4.static.sl-reverse.com [169.47.144.26]) by mx0a-001b2d01.pphosted.com with ESMTP id 316y4tbwkv-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Mon, 25 May 2020 07:46:54 -0400 Received: from pps.filterd (ppma04wdc.us.ibm.com [127.0.0.1]) by ppma04wdc.us.ibm.com (8.16.0.42/8.16.0.42) with SMTP id 04PBiaCK014270; Mon, 25 May 2020 11:46:53 GMT Received: from b03cxnp08027.gho.boulder.ibm.com (b03cxnp08027.gho.boulder.ibm.com [9.17.130.19]) by ppma04wdc.us.ibm.com with ESMTP id 316uf9bhvd-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Mon, 25 May 2020 11:46:53 +0000 Received: from b03ledav004.gho.boulder.ibm.com (b03ledav004.gho.boulder.ibm.com [9.17.130.235]) by b03cxnp08027.gho.boulder.ibm.com (8.14.9/8.14.9/NCO v10.0) with ESMTP id 04PBkpG612255716 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Mon, 25 May 2020 11:46:51 GMT Received: from b03ledav004.gho.boulder.ibm.com (unknown [127.0.0.1]) by IMSVA (Postfix) with ESMTP id 8823F78064; Mon, 25 May 2020 11:46:52 +0000 (GMT) Received: from b03ledav004.gho.boulder.ibm.com (unknown [127.0.0.1]) by IMSVA (Postfix) with ESMTP id ECC837805C; Mon, 25 May 2020 11:46:51 +0000 (GMT) Received: from localhost (unknown [9.163.82.98]) by b03ledav004.gho.boulder.ibm.com (Postfix) with ESMTP; Mon, 25 May 2020 11:46:51 +0000 (GMT) Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable In-Reply-To: <158921890091.13128.8968594041404693853@localhost.localdomain> References: <20200407135947.15344-1-lamm@linux.ibm.com> <20200421174456.28663-1-lamm@linux.ibm.com> <158921890091.13128.8968594041404693853@localhost.localdomain> Subject: Re: [PATCH v9] Fix time/tst-cpuclock1 intermitent failures From: "Lucas A. M. Magalhaes" To: libc-alpha@sourceware.org Date: Mon, 25 May 2020 08:46:50 -0300 Message-ID: <159040721073.97673.15122051171014634453@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.676 definitions=2020-05-25_05:2020-05-25, 2020-05-25 signatures=0 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 suspectscore=0 malwarescore=0 adultscore=0 impostorscore=0 phishscore=0 spamscore=0 cotscore=-2147483648 lowpriorityscore=0 mlxscore=0 priorityscore=1501 mlxlogscore=999 clxscore=1015 bulkscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2004280000 definitions=main-2005250087 X-Spam-Status: No, score=-14.4 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: Mon, 25 May 2020 11:46:58 -0000 PING Quoting Lucas A. M. Magalhaes (2020-05-11 14:41:40) > PING. >=20 > Quoting Lucas A. M. Magalhaes via Libc-alpha (2020-04-21 14:44:56) > > This test fails intermittently in systems with heavy load as > > CLOCK_PROCESS_CPUTIME_ID is subject to scheduler pressure. Thus the > > test boundaries were relaxed to keep it from failing on such systems. > >=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 > > Hi Carlos, > > I also got skeptical about my dataset so I genegerated another one. > > That .4 boundry was indeed too low. Also, the support/tst-timespec was > > not actually running any tests because of a lazy bug, sorry about that. > > Thanks for taking the time for reviewing this. > >=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 6e38b87ebe..cacaac96a5 100644 > > --- a/support/Makefile > > +++ b/support/Makefile > > @@ -233,6 +233,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..103beafdc4 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,= int line, > > (intmax_t) diff.tv_sec, (intmax_t) diff.tv_nsec); > > } > > } > > + > > +/* Convert TIME to nanoseconds stored in shrinked in a long. > > + Returns long maximum or minimum if the conversion overflows > > + or underflows, respectively. */ > > +long > > +support_timespec_ns (struct timespec time) > > +{ > > + long time_ns; > > + if (INT_MULTIPLY_WRAPV(time.tv_sec, TIMESPEC_HZ, &time_ns)) > > + { > > + return (time.tv_sec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long= ); > > + } > > + if (INT_ADD_WRAPV(time_ns, time.tv_nsec, &time_ns)) > > + { > > + return (time.tv_nsec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(lon= g); > > + } > > + return time_ns; > > +} > > + > > +/* Returns t normalized timespec with .tv_nsec < TIMESPEC_HZ > > + and the whole seconds added to .tv_sec. If an overflow or > > + underflow occurs the values are clamped to its maximum or > > + minimum respectively. */ > > +struct timespec > > +support_timespec_normalize (struct timespec time) > > +{ > > + struct timespec norm; > > + if (INT_ADD_WRAPV (time.tv_sec, (time.tv_nsec / TIMESPEC_HZ), &norm.= tv_sec)) > > + { > > + norm.tv_sec =3D (time.tv_nsec < 0) ? TYPE_MINIMUM (time_t): TYPE_= MAXIMUM (time_t); > > + norm.tv_nsec =3D (time.tv_nsec < 0) ? -1 * (TIMESPEC_HZ - 1) : TI= MESPEC_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, .5, 1.2); > > + > > + will check if > > + > > + .5 <=3D observed/expected <=3D 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 time= spec 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 *= file, 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 = timespec observed, > > + double lower_bound, double upper_boun= d); > > + > > + > > /* Check that the timespec on the left represents a time before the > > time on the right. */ > > #define TEST_TIMESPEC_BEFORE(left, right) = \ > > diff --git a/support/tst-timespec.c b/support/tst-timespec.c > > new file mode 100644 > > index 0000000000..b421b219fd > > --- /dev/null > > +++ b/support/tst-timespec.c > > @@ -0,0 +1,320 @@ > > +/* Test for support_timespec_check_in_range function. > > + Copyright (C) 2020 Free Software Foundation, Inc. > > + This file is part of the GNU C Library. > > + > > + The GNU C Library is free software; you can redistribute it and/or > > + modify it under the terms of the GNU Lesser General Public > > + License as published by the Free Software Foundation; either > > + version 2.1 of the License, or (at your option) any later version. > > + > > + The GNU C Library is distributed in the hope that it will be useful, > > + but WITHOUT ANY WARRANTY; without even the implied warranty of > > + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU > > + Lesser General Public License for more details. > > + > > + You should have received a copy of the GNU Lesser General Public > > + License along with the GNU C Library; if not, see > > + . */ > > + > > +#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_MA= X%TIMESPEC_HZ - 1}, > > + .time_ns =3D LONG_MAX - 1, > > + }, > > + // Overflow bondary > > + {.time =3D {.tv_sec =3D LONG_MAX / TIMESPEC_HZ, .tv_nsec =3D LONG_MA= X%TIMESPEC_HZ}, > > + .time_ns =3D LONG_MAX, > > + }, > > + // Underflow bondary by 1 > > + {.time =3D {.tv_sec =3D LONG_MIN / TIMESPEC_HZ, .tv_nsec =3D LONG_MI= N%TIMESPEC_HZ + 1}, > > + .time_ns =3D LONG_MIN + 1, > > + }, > > + // Underflow bondary > > + {.time =3D {.tv_sec =3D LONG_MIN / TIMESPEC_HZ, .tv_nsec =3D LONG_MI= N%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_MA= X%TIMESPEC_HZ + 1}, > > + .time_ns =3D LONG_MAX, > > + }, > > + // Sum underflow > > + {.time =3D {.tv_sec =3D LONG_MIN / TIMESPEC_HZ, .tv_nsec =3D LONG_MI= N%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, .resu= lt =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, .res= ult =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.0000099997999= 9, .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 TI= MESPEC_HZ - 1}, > > + .observed =3D {.tv_sec =3D 0, .tv_nsec =3D 1}, > > + .upper_bound =3D 1, .lower_bound =3D 1.0842021724855044e-19, .resul= t =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 TI= MESPEC_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= report. > > + So here we print every running testcase as well. */ > > + printf("Test case %d\n", i); > > + TEST_COMPARE (support_timespec_check_in_range > > + (check_cases[i].expected, check_cases[i].observed, > > + check_cases[i].lower_bound, > > + check_cases[i].upper_bound), check_cases[i].result= ); > > + } > > + return 0; > > +} > > + > > +#include > > 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 ove= r high cpu > > + usage and different nice values. Of all the values we keep the 90= th > > + percentile of values and use those values for our testing allowed= range. */ > > + struct timespec diff =3D timespec_sub (support_timespec_normalize (a= fter), > > + support_timespec_normalize (befo= re)); > > + 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= _sec, > > - .tv_nsec =3D afterns.tv_nsec - after.tv= _nsec }; > > - 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 co= de over > > + high cpu usage and different nice values. Of all the values= we keep > > + the 90th percentile of values and use those values for our = testing > > + allowed range. */ > > + diff =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 rang= e\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 ove= r high cpu > > + usage and different nice values. Of all the values we keep the 90= th > > + percentile of values and use those values for our testing allowed= range. */ > > + 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.20.1 > >