From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from us-smtp-1.mimecast.com (us-smtp-1.mimecast.com [207.211.31.81]) by sourceware.org (Postfix) with ESMTP id E896F385DC00 for ; Mon, 8 Jun 2020 16:55:31 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.3.2 sourceware.org E896F385DC00 Received: from mail-qt1-f197.google.com (mail-qt1-f197.google.com [209.85.160.197]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-124-PHSmxmoEOry8tjr54Jkw4g-1; Mon, 08 Jun 2020 12:52:17 -0400 X-MC-Unique: PHSmxmoEOry8tjr54Jkw4g-1 Received: by mail-qt1-f197.google.com with SMTP id c22so14733846qtp.9 for ; Mon, 08 Jun 2020 09:52:17 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:subject:to:references:from:organization :message-id:date:user-agent:mime-version:in-reply-to :content-language:content-transfer-encoding; bh=4Er6vqzndRZ8WnEn3eLYTQnKxG/dQmTdLqp6YjF/8SI=; b=pt+rGtAoWWrIqoiq9LhLOyJ+2YvCavFy6lRNb7ow4o8PcXTX+2umOuHvsDUeOeURIe FGxDqLqUSA60BccTgn8zU9SPSAMIH2q8wCqW71Ew41lftGdcpXZLmN0J4Y8y5EMN0gRg 3NTtd8myheaEFZQ8tE4QbKfPBRkINE4uft9PJ1Nj+TAHEsVPFYqUtCs9eKodSiYhDtMu G73x7RdEqBDwwJx8Tu8gyFYHp2AqwG6nMkON5fjjN+KwPaAZ8VGyC1hxgN08g4pbbC97 LSIW65QTptApXwJYmRD2zcRKilDVyZKAvMV1ItnUMPQOonjG07UjKYZE3L89K0qYwEiR VGWg== X-Gm-Message-State: AOAM530kXydgCckgtfAR8aGwDt9SRLKiuCUgKaTk4v8m+QPrawWCFXf2 sJ2X3WD4EKIVJPgcUvXOoz+7Tjc8M1u+yZNmzBbnurq9KGKMb2gLJEeHNBSV4zn1DCwDK+0mwy2 dUIhdkRXotpyOdr+xx+ov X-Received: by 2002:a37:b585:: with SMTP id e127mr22548809qkf.336.1591635136683; Mon, 08 Jun 2020 09:52:16 -0700 (PDT) X-Google-Smtp-Source: ABdhPJy6P9+aVY5OC3NWCx4lRwQPZmItgHEGZstyTYiCix9ySa2nGY4IyD+TVmcLTigCeDOOVYXmXw== X-Received: by 2002:a37:b585:: with SMTP id e127mr22548778qkf.336.1591635136155; Mon, 08 Jun 2020 09:52:16 -0700 (PDT) Received: from [192.168.1.4] (198-84-170-103.cpe.teksavvy.com. [198.84.170.103]) by smtp.gmail.com with ESMTPSA id r195sm6224219qka.12.2020.06.08.09.52.14 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Mon, 08 Jun 2020 09:52:15 -0700 (PDT) Subject: Re: [PATCH v9] Fix time/tst-cpuclock1 intermitent failures To: "Lucas A. M. Magalhaes" , libc-alpha@sourceware.org References: <20200407135947.15344-1-lamm@linux.ibm.com> <20200421174456.28663-1-lamm@linux.ibm.com> From: Carlos O'Donell Organization: Red Hat Message-ID: <5f878f53-ceec-289e-5390-eeed17efc383@redhat.com> Date: Mon, 8 Jun 2020 12:52:13 -0400 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Thunderbird/68.7.0 MIME-Version: 1.0 In-Reply-To: <20200421174456.28663-1-lamm@linux.ibm.com> Content-Language: en-US X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Type: text/plain; charset=windows-1252 Content-Transfer-Encoding: 7bit X-Spam-Status: No, score=-12.8 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, KAM_SHORT, RCVD_IN_DNSWL_NONE, RCVD_IN_MSPIKE_H4, RCVD_IN_MSPIKE_WL, 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, 08 Jun 2020 16:55:34 -0000 On 4/21/20 1:44 PM, Lucas A. M. Magalhaes wrote: > This test fails intermittently in systems with heavy load as > CLOCK_PROCESS_CPUTIME_ID is subject to scheduler pressure. Thus the > test boundaries were relaxed to keep it from failing on such systems. > > A refactor of the spent time checking was made with some support > functions. With the advantage to representing time jitter in percent > of the target. > > The values used by the test boundaries are all empirical. > > --- > > Hi Carlos, > I also got skeptical about my dataset so I genegerated another one. > That .4 boundry was indeed too low. Also, the support/tst-timespec was > not actually running any tests because of a lazy bug, sorry about that. > Thanks for taking the time for reviewing this. *Almost* done. Please review suggestions and comment changes. Post v10 and I'll ACK that. > changes on V9: > Add new testcases > Fix support/tst-timespec do_run > Add comments > Change boundaries > > changes on V8: > Add support_timespec_ns > Add more tests > > This list of changes where getting to long. > --- > support/Makefile | 1 + > support/timespec.c | 64 +++++++++ > support/timespec.h | 8 ++ > support/tst-timespec.c | 320 +++++++++++++++++++++++++++++++++++++++++ > time/tst-cpuclock1.c | 52 +++---- > 5 files changed, 415 insertions(+), 30 deletions(-) > create mode 100644 support/tst-timespec.c > > diff --git a/support/Makefile b/support/Makefile > index 6e38b87ebe..cacaac96a5 100644 > --- a/support/Makefile > +++ b/support/Makefile > @@ -233,6 +233,7 @@ tests = \ > tst-test_compare \ > tst-test_compare_blob \ > tst-test_compare_string \ > + tst-timespec \ OK. Add new test. > tst-xreadlink \ > tst-xsigstack \ > > diff --git a/support/timespec.c b/support/timespec.c > index ea6b947546..103beafdc4 100644 > --- a/support/timespec.c > +++ b/support/timespec.c > @@ -19,6 +19,8 @@ > #include > #include > #include > +#include > +#include OK. > > void > test_timespec_before_impl (const char *file, int line, > @@ -57,3 +59,65 @@ test_timespec_equal_or_after_impl (const char *file, int line, > (intmax_t) diff.tv_sec, (intmax_t) diff.tv_nsec); > } > } > + > +/* Convert TIME to nanoseconds stored in shrinked in a long. Suggest: Convert TIME to nanoseconds stored in a long. > + Returns long maximum or minimum if the conversion overflows > + or underflows, respectively. */ OK. Good we document that we clamp at max or min with no wrapping. > +long > +support_timespec_ns (struct timespec time) > +{ > + long time_ns; > + if (INT_MULTIPLY_WRAPV(time.tv_sec, TIMESPEC_HZ, &time_ns)) > + { > + return (time.tv_sec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long); OK. Negative multiply that wraps clamps to minimum negative long, while positive multiple that wraps clamps to maximum positive long. > + } > + if (INT_ADD_WRAPV(time_ns, time.tv_nsec, &time_ns)) > + { > + return (time.tv_nsec < 0) ? TYPE_MINIMUM(long): TYPE_MAXIMUM(long); OK. Likewise for addition. > + } > + return time_ns; > +} > + > +/* Returns t normalized timespec with .tv_nsec < TIMESPEC_HZ Suggest: Returns time normalized timespec with .tv_nsec < TIMESPEC_HZ > + and the whole seconds added to .tv_sec. If an overflow or > + underflow occurs the values are clamped to its maximum or > + minimum respectively. */ > +struct timespec > +support_timespec_normalize (struct timespec time) > +{ > + struct timespec norm; > + if (INT_ADD_WRAPV (time.tv_sec, (time.tv_nsec / TIMESPEC_HZ), &norm.tv_sec)) > + { > + norm.tv_sec = (time.tv_nsec < 0) ? TYPE_MINIMUM (time_t): TYPE_MAXIMUM (time_t); OK. Yes, seconds clamp at min or max for the type. Which is normalized. > + norm.tv_nsec = (time.tv_nsec < 0) ? -1 * (TIMESPEC_HZ - 1) : TIMESPEC_HZ - 1; OK. Yes, nanoseconds clamp at min or max of (TIMESPEC_HZ - 1). > + return norm; > + } > + norm.tv_nsec = time.tv_nsec % TIMESPEC_HZ; OK. > + return norm; > +} > + > +/* Returns TRUE if the observed time is within the given percentage > + bounds of the expected time, and FALSE otherwise. > + For example the call > + > + support_timespec_check_in_range(expected, observed, .5, 1.2); Suggest: support_timespec_check_in_range(expected, observed, 0.5, 1.2); > + > + will check if > + > + .5 <= observed/expected <= 1.2 Suggest: 50% of expected <= observed <= 120% of expected > + > + In other words it will check if observed time is within 50% to > + 120% of the expected time. */ > +int > +support_timespec_check_in_range (struct timespec expected, struct timespec observed, > + double lower_bound, double upper_bound) > +{ > + assert (upper_bound >= lower_bound); > + long expected_norm, observed_norm; > + expected_norm = support_timespec_ns (expected); > + /* Don't divide by zero */ > + assert(expected_norm != 0); > + observed_norm = support_timespec_ns (observed); > + double ratio = (double)observed_norm / expected_norm; > + return (lower_bound <= ratio && ratio <= upper_bound); OK. > +} > diff --git a/support/timespec.h b/support/timespec.h > index c5852dfe75..fd5466745d 100644 > --- a/support/timespec.h > +++ b/support/timespec.h > @@ -48,6 +48,14 @@ void test_timespec_equal_or_after_impl (const char *file, int line, > const struct timespec left, > const struct timespec right); > > +long support_timespec_ns (struct timespec time); > + > +struct timespec support_timespec_normalize (struct timespec time); > + > +int support_timespec_check_in_range (struct timespec expected, struct timespec observed, > + double lower_bound, double upper_bound); OK. > + > + > /* Check that the timespec on the left represents a time before the > time on the right. */ > #define TEST_TIMESPEC_BEFORE(left, right) \ > diff --git a/support/tst-timespec.c b/support/tst-timespec.c > new file mode 100644 > index 0000000000..b421b219fd > --- /dev/null > +++ b/support/tst-timespec.c > @@ -0,0 +1,320 @@ > +/* Test for support_timespec_check_in_range function. > + Copyright (C) 2020 Free Software Foundation, Inc. > + This file is part of the GNU C Library. > + > + The GNU C Library is free software; you can redistribute it and/or > + modify it under the terms of the GNU Lesser General Public > + License as published by the Free Software Foundation; either > + version 2.1 of the License, or (at your option) any later version. > + > + The GNU C Library is distributed in the hope that it will be useful, > + but WITHOUT ANY WARRANTY; without even the implied warranty of > + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU > + Lesser General Public License for more details. > + > + You should have received a copy of the GNU Lesser General Public > + License along with the GNU C Library; if not, see > + . */ > + > +#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[] = { > + {.time = {.tv_sec = 0, .tv_nsec = 0}, > + .time_ns = 0, > + }, > + {.time = {.tv_sec = 0, .tv_nsec = 1}, > + .time_ns = 1, > + }, > + {.time = {.tv_sec = 1, .tv_nsec = 0}, > + .time_ns = TIMESPEC_HZ, > + }, > + {.time = {.tv_sec = 1, .tv_nsec = 1}, > + .time_ns = TIMESPEC_HZ + 1, > + }, > + {.time = {.tv_sec = 0, .tv_nsec = -1}, > + .time_ns = -1, > + }, > + {.time = {.tv_sec = -1, .tv_nsec = 0}, > + .time_ns = -TIMESPEC_HZ, > + }, > + {.time = {.tv_sec = -1, .tv_nsec = -1}, > + .time_ns = -TIMESPEC_HZ - 1, > + }, > + {.time = {.tv_sec = 1, .tv_nsec = -1}, > + .time_ns = TIMESPEC_HZ - 1, > + }, > + {.time = {.tv_sec = -1, .tv_nsec = 1}, > + .time_ns = -TIMESPEC_HZ + 1, > + }, > + // Overflow bondary by 2 Change all of these comments to use GNU-style e.g. /* Foo. */ > + {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ, .tv_nsec = LONG_MAX%TIMESPEC_HZ - 1}, > + .time_ns = LONG_MAX - 1, > + }, > + // Overflow bondary > + {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ, .tv_nsec = LONG_MAX%TIMESPEC_HZ}, > + .time_ns = LONG_MAX, > + }, > + // Underflow bondary by 1 > + {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ, .tv_nsec = LONG_MIN%TIMESPEC_HZ + 1}, > + .time_ns = LONG_MIN + 1, > + }, > + // Underflow bondary > + {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ, .tv_nsec = LONG_MIN%TIMESPEC_HZ}, > + .time_ns = LONG_MIN, > + }, > + // Multiplication overflow > + {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ + 1, .tv_nsec = 1}, > + .time_ns = LONG_MAX, > + }, > + // Multiplication underflow > + {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ - 1, .tv_nsec = -1}, > + .time_ns = LONG_MIN, > + }, > + // Sum overflows > + {.time = {.tv_sec = LONG_MAX / TIMESPEC_HZ, .tv_nsec = LONG_MAX%TIMESPEC_HZ + 1}, > + .time_ns = LONG_MAX, > + }, > + // Sum underflow > + {.time = {.tv_sec = LONG_MIN / TIMESPEC_HZ, .tv_nsec = LONG_MIN%TIMESPEC_HZ - 1}, > + .time_ns = LONG_MIN, > + } > +}; > + > +/* Test cases for timespec_norm */ > +struct timespec_norm_test_case norm_cases[] = { > + // Positive cases > + {.time = {.tv_sec = 0, .tv_nsec = 0}, > + .norm = {.tv_sec = 0, .tv_nsec = 0} > + }, > + {.time = {.tv_sec = 1, .tv_nsec = 0}, > + .norm = {.tv_sec = 1, .tv_nsec = 0} > + }, > + {.time = {.tv_sec = 0, .tv_nsec = 1}, > + .norm = {.tv_sec = 0, .tv_nsec = 1} > + }, > + {.time = {.tv_sec = 0, .tv_nsec = TIMESPEC_HZ}, > + .norm = {.tv_sec = 1, .tv_nsec = 0} > + }, > + {.time = {.tv_sec = 0, .tv_nsec = TIMESPEC_HZ + 1}, > + .norm = {.tv_sec = 1, .tv_nsec = 1} > + }, > + {.time = {.tv_sec = 1, .tv_nsec = TIMESPEC_HZ}, > + .norm = {.tv_sec = 2, .tv_nsec = 0} > + }, > + {.time = {.tv_sec = 1, .tv_nsec = TIMESPEC_HZ + 1}, > + .norm = {.tv_sec = 2, .tv_nsec = 1} > + }, > + // Negative cases > + {.time = {.tv_sec = 0, .tv_nsec = -TIMESPEC_HZ}, > + .norm = {.tv_sec = -1, .tv_nsec = 0} > + }, > + {.time = {.tv_sec = 0, .tv_nsec = -TIMESPEC_HZ - 1}, > + .norm = {.tv_sec = -1, .tv_nsec = -1} > + }, > + {.time = {.tv_sec = -1, .tv_nsec = -TIMESPEC_HZ}, > + .norm = {.tv_sec = -2, .tv_nsec = 0} > + }, > + {.time = {.tv_sec = -1, .tv_nsec = -TIMESPEC_HZ - 1}, > + .norm = {.tv_sec = -2, .tv_nsec = -1} > + }, > + // Overflow bondary by 2 > + {.time = {.tv_sec = LONG_MAX - 2, .tv_nsec = TIMESPEC_HZ + 1}, > + .norm = {.tv_sec = LONG_MAX - 1, 1}, > + }, > + // Overflow bondary by 1 > + {.time = {.tv_sec = LONG_MAX - 1, .tv_nsec = TIMESPEC_HZ + 1}, > + .norm = {.tv_sec = LONG_MAX, .tv_nsec = 1}, > + }, > + // Underflow bondary by 2 > + {.time = {.tv_sec = LONG_MIN + 2, .tv_nsec = -TIMESPEC_HZ - 1}, > + .norm = {.tv_sec = LONG_MIN + 1, -1}, > + }, > + // Underflow bondary by 1 > + {.time = {.tv_sec = LONG_MIN + 1, .tv_nsec = -TIMESPEC_HZ - 1}, > + .norm = {.tv_sec = LONG_MIN, .tv_nsec = -1}, > + }, > + // SUM overflow > + {.time = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ}, > + .norm = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ - 1}, > + }, > + // SUM underflow > + {.time = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ}, > + .norm = {.tv_sec = LONG_MIN, .tv_nsec = -1 * (TIMESPEC_HZ - 1)}, > + } > +}; > + > +/* Test cases for timespec_check_in_range */ > +struct timespec_test_case check_cases[] = { > + // 0 - In range > + {.expected = {.tv_sec = 1, .tv_nsec = 0}, > + .observed = {.tv_sec = 1, .tv_nsec = 0}, > + .upper_bound = 1, .lower_bound = 1, .result = 1, > + }, > + // 1 - Out of range > + {.expected = {.tv_sec = 1, .tv_nsec = 0}, > + .observed = {.tv_sec = 2, .tv_nsec = 0}, > + .upper_bound = 1, .lower_bound = 1, .result = 0, > + }, > + // 2 - Upper Bound > + {.expected = {.tv_sec = 1, .tv_nsec = 0}, > + .observed = {.tv_sec = 2, .tv_nsec = 0}, > + .upper_bound = 2, .lower_bound = 1, .result = 1, > + }, > + // 3 - Lower Bound > + {.expected = {.tv_sec = 1, .tv_nsec = 0}, > + .observed = {.tv_sec = 0, .tv_nsec = 0}, > + .upper_bound = 1, .lower_bound = 0, .result = 1, > + }, > + // 4 - Out of range by nanosecs > + {.expected = {.tv_sec = 1, .tv_nsec = 0}, > + .observed = {.tv_sec = 1, .tv_nsec = 500}, > + .upper_bound = 1, .lower_bound = 1, .result = 0, > + }, > + // 5 - In range by nanosecs > + {.expected = {.tv_sec = 1, .tv_nsec = 0}, > + .observed = {.tv_sec = 1, .tv_nsec = 50000}, > + .upper_bound = 1.3, .lower_bound = 1, .result = 1, > + }, > + // 6 - Big nanosecs > + {.expected = {.tv_sec = 1, .tv_nsec = 0}, > + .observed = {.tv_sec = 0, .tv_nsec = 4000000}, > + .upper_bound = 1, .lower_bound = .001, .result = 1, > + }, > + // 7 - In range Negative values > + {.expected = {.tv_sec = -1, .tv_nsec = 0}, > + .observed = {.tv_sec = -1, .tv_nsec = 0}, > + .upper_bound = 1, .lower_bound = 1, .result = 1, > + }, > + // 8 - Out of range Negative values > + {.expected = {.tv_sec = -1, .tv_nsec = 0}, > + .observed = {.tv_sec = -1, .tv_nsec = 0}, > + .upper_bound = -1, .lower_bound = -1, .result = 0, > + }, > + // 9 - Negative values with negative nanosecs > + {.expected = {.tv_sec = -1, .tv_nsec = 0}, > + .observed = {.tv_sec = -1, .tv_nsec = -2000}, > + .upper_bound = 1, .lower_bound = 1, .result = 0, > + }, > + // 10 - Strict bounds > + {.expected = {.tv_sec = -1, .tv_nsec = 0}, > + .observed = {.tv_sec = -1, .tv_nsec = -20000}, > + .upper_bound = 1.00002, .lower_bound = 1.0000191, .result = 1, > + }, > + // 11 - Strict bounds with loose upper bound > + {.expected = {.tv_sec = 1, .tv_nsec = 20000}, > + .observed = {.tv_sec = 1, .tv_nsec = 30000}, > + .upper_bound = 1.0000100000, .lower_bound = 1.0000099998, .result = 1, > + }, > + // 12 - Strict bounds with loose lower bound > + {.expected = {.tv_sec = 1, .tv_nsec = 20000}, > + .observed = {.tv_sec = 1, .tv_nsec = 30000}, > + .upper_bound = 1.0000099999, .lower_bound = 1.00000999979, .result = 1, > + }, > + // 13 - Strict bounds highest precision > + {.expected = {.tv_sec = 1, .tv_nsec = 20000}, > + .observed = {.tv_sec = 1, .tv_nsec = 30000}, > + .upper_bound = 1.00000999980001, .lower_bound = 1.00000999979999, .result = 1, > + }, > + /* Maximum/Minimum long values */ > + // 14 > + {.expected = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ - 1}, > + .observed = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ - 2}, > + .upper_bound = 1, .lower_bound = .9, .result = 1, > + }, > + // 15 - support_timespec_ns overflow > + {.expected = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ}, > + .observed = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ}, > + .upper_bound = 1, .lower_bound = 1, .result = 1, > + }, > + // 16 - support_timespec_ns overflow + underflow > + {.expected = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ}, > + .observed = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ}, > + .upper_bound = 1, .lower_bound = 1, .result = 0, > + }, > + // 17 - support_timespec_ns underflow > + {.expected = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ}, > + .observed = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ}, > + .upper_bound = 1, .lower_bound = 1, .result = 1, > + }, > + // 18 - support_timespec_ns underflow + overflow > + {.expected = {.tv_sec = LONG_MIN, .tv_nsec = -TIMESPEC_HZ}, > + .observed = {.tv_sec = LONG_MAX, .tv_nsec = TIMESPEC_HZ}, > + .upper_bound = 1, .lower_bound = 1, .result = 0, > + }, > + // 19 - Biggest division > + {.expected = {.tv_sec = LONG_MAX / TIMESPEC_HZ , .tv_nsec = TIMESPEC_HZ - 1}, > + .observed = {.tv_sec = 0, .tv_nsec = 1}, > + .upper_bound = 1, .lower_bound = 1.0842021724855044e-19, .result = 1, > + }, > + // 20 - Lowest division > + {.expected = {.tv_sec = 0, .tv_nsec = 1}, > + .observed = {.tv_sec = LONG_MAX / TIMESPEC_HZ , .tv_nsec = TIMESPEC_HZ - 1}, > + .upper_bound = LONG_MAX, .lower_bound = 1, .result = 1, > + }, > +}; > + > +static int > +do_test (void) > +{ > + int i = 0; > + int ntests = sizeof (ns_cases) / sizeof (ns_cases[0]); > + > + printf("Testing support_timespec_ns\n"); > + for (i = 0; i < ntests; i++) > + { > + TEST_COMPARE (support_timespec_ns (ns_cases[i].time), > + ns_cases[i].time_ns); > + } > + > + ntests = sizeof (norm_cases) / sizeof (norm_cases[0]); > + struct timespec result; > + printf("Testing support_timespec_normalize\n"); > + for (i = 0; i < ntests; i++) > + { > + result = support_timespec_normalize (norm_cases[i].time); > + TEST_COMPARE (norm_cases[i].norm.tv_sec, result.tv_sec); > + TEST_COMPARE (norm_cases[i].norm.tv_nsec, result.tv_nsec); > + } > + > + ntests = sizeof (check_cases) / sizeof (check_cases[0]); > + printf("Testing support_timespec_check_in_range\n"); > + for (i = 0; i < ntests; i++) > + { > + /* Its hard to find which test failed with just the TEST_COMPARE report. > + So here we print every running testcase as well. */ > + printf("Test case %d\n", i); > + TEST_COMPARE (support_timespec_check_in_range > + (check_cases[i].expected, check_cases[i].observed, > + check_cases[i].lower_bound, > + check_cases[i].upper_bound), check_cases[i].result); > + } > + return 0; > +} > + > +#include OK. > diff --git a/time/tst-cpuclock1.c b/time/tst-cpuclock1.c > index 0120906f23..1ac611a92b 100644 > --- a/time/tst-cpuclock1.c > +++ b/time/tst-cpuclock1.c > @@ -26,6 +26,7 @@ > #include > #include > #include > +#include > > /* This function is intended to rack up both user and system time. */ > static void > @@ -155,16 +156,12 @@ do_test (void) > printf ("live PID %d after sleep => %ju.%.9ju\n", > child, (uintmax_t) after.tv_sec, (uintmax_t) after.tv_nsec); > > - struct timespec diff = { .tv_sec = after.tv_sec - before.tv_sec, > - .tv_nsec = after.tv_nsec - before.tv_nsec }; > - if (diff.tv_nsec < 0) > - { > - --diff.tv_sec; > - diff.tv_nsec += 1000000000; > - } > - if (diff.tv_sec != 0 > - || diff.tv_nsec > 600000000 > - || diff.tv_nsec < 100000000) > + /* The bound values are empirically defined by testing this code over high cpu > + usage and different nice values. Of all the values we keep the 90th > + percentile of values and use those values for our testing allowed range. */ > + struct timespec diff = timespec_sub (support_timespec_normalize (after), > + support_timespec_normalize (before)); > + if (!support_timespec_check_in_range (sleeptime, diff, .9, 1.1)) OK. > { > printf ("before - after %ju.%.9ju outside reasonable range\n", > (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec); > @@ -194,19 +191,16 @@ do_test (void) > } > else > { > - struct timespec d = { .tv_sec = afterns.tv_sec - after.tv_sec, > - .tv_nsec = afterns.tv_nsec - after.tv_nsec }; > - if (d.tv_nsec < 0) > - { > - --d.tv_sec; > - d.tv_nsec += 1000000000; > - } > - if (d.tv_sec > 0 > - || d.tv_nsec < sleeptime.tv_nsec > - || d.tv_nsec > sleeptime.tv_nsec * 2) > + /* The bound values are empirically defined by testing this code over > + high cpu usage and different nice values. Of all the values we keep > + the 90th percentile of values and use those values for our testing > + allowed range. */ > + diff = timespec_sub (support_timespec_normalize (afterns), > + support_timespec_normalize (after)); > + if (!support_timespec_check_in_range (sleeptime, diff, .9, 1.2)) OK. > { > printf ("nanosleep time %ju.%.9ju outside reasonable range\n", > - (uintmax_t) d.tv_sec, (uintmax_t) d.tv_nsec); > + (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec); > result = 1; > } > } > @@ -240,15 +234,13 @@ do_test (void) > /* Should be close to 0.6. */ > printf ("dead PID %d => %ju.%.9ju\n", > child, (uintmax_t) dead.tv_sec, (uintmax_t) dead.tv_nsec); > - > - diff.tv_sec = dead.tv_sec - after.tv_sec; > - diff.tv_nsec = dead.tv_nsec - after.tv_nsec; > - if (diff.tv_nsec < 0) > - { > - --diff.tv_sec; > - diff.tv_nsec += 1000000000; > - } > - if (diff.tv_sec != 0 || diff.tv_nsec > 200000000) > + /* The bound values are empirically defined by testing this code over high cpu > + usage and different nice values. Of all the values we keep the 90th > + percentile of values and use those values for our testing allowed range. */ > + diff = timespec_sub (support_timespec_normalize (dead), > + support_timespec_normalize (after)); > + sleeptime.tv_nsec = 100000000; > + if (!support_timespec_check_in_range (sleeptime, diff, .9, 1.2)) OK. > { > printf ("dead - after %ju.%.9ju outside reasonable range\n", > (uintmax_t) diff.tv_sec, (uintmax_t) diff.tv_nsec); > -- Cheers, Carlos.