From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on dcvr.yhbt.net X-Spam-Level: X-Spam-Status: No, score=-4.2 required=3.0 tests=AWL,BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,MAILING_LIST_MULTI, SPF_HELO_PASS,SPF_PASS shortcircuit=no autolearn=ham autolearn_force=no version=3.4.2 Received: from sourceware.org (server2.sourceware.org [8.43.85.97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by dcvr.yhbt.net (Postfix) with ESMTPS id 472DA1F5AE for ; Mon, 6 Jul 2020 14:15:59 +0000 (UTC) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 6FF623857C5A; Mon, 6 Jul 2020 14:15:58 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 6FF623857C5A DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1594044958; bh=uSPd8JU0179SwQU2KDl3bBcryox5/kDD1MLyy8o6VDQ=; h=In-Reply-To:References:Subject:To:Date:List-Id:List-Unsubscribe: List-Archive:List-Post:List-Help:List-Subscribe:From:Reply-To: From; b=RinSVHVoQzjXE3a75H3/pm4az6gZd88kyL1OzwKOsA7h+yKDpqSy8A741INky6nNm EriJKZgSTlWfY9NJhRHDeXlZaBaGBeikC2OIhT4JqUGbQFS8iXhB5GLha1J6lNdPDC V5uBo7ws3K187sZo5fPHOM/A1mGe5yinj1lkx13o= Received: from mx0a-001b2d01.pphosted.com (mx0a-001b2d01.pphosted.com [148.163.156.1]) by sourceware.org (Postfix) with ESMTPS id 38AE33858D37 for ; Mon, 6 Jul 2020 14:15:55 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.3.2 sourceware.org 38AE33858D37 Received: from pps.filterd (m0098394.ppops.net [127.0.0.1]) by mx0a-001b2d01.pphosted.com (8.16.0.42/8.16.0.42) with SMTP id 066E1kgo027022 for ; Mon, 6 Jul 2020 10:15:54 -0400 Received: from pps.reinject (localhost [127.0.0.1]) by mx0a-001b2d01.pphosted.com with ESMTP id 322p98cqc0-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT) for ; Mon, 06 Jul 2020 10:15:54 -0400 Received: from m0098394.ppops.net (m0098394.ppops.net [127.0.0.1]) by pps.reinject (8.16.0.36/8.16.0.36) with SMTP id 066ED1eZ079757 for ; Mon, 6 Jul 2020 10:15:53 -0400 Received: from ppma05wdc.us.ibm.com (1b.90.2fa9.ip4.static.sl-reverse.com [169.47.144.27]) by mx0a-001b2d01.pphosted.com with ESMTP id 322p98cqbb-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Mon, 06 Jul 2020 10:15:53 -0400 Received: from pps.filterd (ppma05wdc.us.ibm.com [127.0.0.1]) by ppma05wdc.us.ibm.com (8.16.0.42/8.16.0.42) with SMTP id 066EAhxa030818; Mon, 6 Jul 2020 14:15:52 GMT Received: from b01cxnp22035.gho.pok.ibm.com (b01cxnp22035.gho.pok.ibm.com [9.57.198.25]) by ppma05wdc.us.ibm.com with ESMTP id 322hd8r1nf-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Mon, 06 Jul 2020 14:15:52 +0000 Received: from b01ledav005.gho.pok.ibm.com (b01ledav005.gho.pok.ibm.com [9.57.199.110]) by b01cxnp22035.gho.pok.ibm.com (8.14.9/8.14.9/NCO v10.0) with ESMTP id 066EFqRn52822426 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Mon, 6 Jul 2020 14:15:52 GMT Received: from b01ledav005.gho.pok.ibm.com (unknown [127.0.0.1]) by IMSVA (Postfix) with ESMTP id 2937EAE062; Mon, 6 Jul 2020 14:15:52 +0000 (GMT) Received: from b01ledav005.gho.pok.ibm.com (unknown [127.0.0.1]) by IMSVA (Postfix) with ESMTP id 74FB8AE05F; Mon, 6 Jul 2020 14:15:51 +0000 (GMT) Received: from localhost (unknown [9.163.56.216]) by b01ledav005.gho.pok.ibm.com (Postfix) with ESMTP; Mon, 6 Jul 2020 14:15:51 +0000 (GMT) Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable In-Reply-To: <159310598033.1139437.17090595691549678135@localhost.localdomain> References: <20200421174456.28663-1-lamm@linux.ibm.com> <20200612152817.1347220-1-lamm@linux.ibm.com> <159310598033.1139437.17090595691549678135@localhost.localdomain> Subject: Re: [PATCH v10] Fix time/tst-cpuclock1 intermitent failures To: libc-alpha@sourceware.org Date: Mon, 06 Jul 2020 11:15:50 -0300 Message-ID: <159404495017.2540402.7967001210617641024@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.235, 18.0.687 definitions=2020-07-06_11:2020-07-06, 2020-07-06 signatures=0 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 bulkscore=0 malwarescore=0 lowpriorityscore=0 phishscore=0 impostorscore=0 priorityscore=1501 clxscore=1015 suspectscore=0 mlxlogscore=999 spamscore=0 mlxscore=0 adultscore=0 cotscore=-2147483648 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2004280000 definitions=main-2007060105 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: , From: "Lucas A. M. Magalhaes via Libc-alpha" Reply-To: "Lucas A. M. Magalhaes" Errors-To: libc-alpha-bounces@sourceware.org Sender: "Libc-alpha" Ping Quoting Lucas A. M. Magalhaes (2020-06-25 14:26:20) > Ping >=20 > 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,= int line, > > (intmax_t) diff.tv_sec, (intmax_t) diff.tv_nsec); > > } > > } > > + > > +/* Convert TIME to nanoseconds stored in a long. > > + Returns long maximum or minimum if the conversion overflows > > + or underflows, respectively. */ > > +long > > +support_timespec_ns (struct timespec time) > > +{ > > + long time_ns; > > + if (INT_MULTIPLY_WRAPV(time.tv_sec, TIMESPEC_HZ, &time_ns)) > > + { > > + return (time.tv_sec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long= ); > > + } > > + if (INT_ADD_WRAPV(time_ns, time.tv_nsec, &time_ns)) > > + { > > + return (time.tv_nsec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(lon= g); > > + } > > + 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_= 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, 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 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..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_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.26.2 > >