Commit 78441c04 authored by Richard Henderson's avatar Richard Henderson Committed by Alex Bennée
Browse files

tests/qht-bench: Adjust threshold computation 



In 06c4cc36, we split the multiplication in two parts to avoid
a clang warning.  But because double still rounds to 53 bits, this
does not provide additional precision beyond multiplication by
nextafter(0x1p64, 0), the largest representable value smaller
than 2**64.

However, since we have eliminated 1.0, mutiplying by 2**64 produces
a better distribution of input values to the output values.

Signed-off-by: default avatarRichard Henderson <richard.henderson@linaro.org>
Reviewed-by: default avatarPhilippe Mathieu-Daudé <philmd@redhat.com>
Signed-off-by: default avatarAlex Bennée <alex.bennee@linaro.org>
Message-Id: <20200626200950.1015121-3-richard.henderson@linaro.org>
parent d11f8249

tests/qht-bench.c

+16 −2
Original line number Diff line number Diff line
@@ -289,11 +289,25 @@ static void pr_params(void) 


static void do_threshold(double rate, uint64_t *threshold)

{

    /*

     * For 0 <= rate <= 1, scale to fit in a uint64_t.

     *

     * Scale by 2**64, with a special case for 1.0.

     * The remainder of the possible values are scattered between 0

     * and 0xfffffffffffff800 (nextafter(0x1p64, 0)).

     *

     * Note that we cannot simply scale by UINT64_MAX, because that

     * value is not representable as an IEEE double value.

     *

     * If we scale by the next largest value, nextafter(0x1p64, 0),

     * then the remainder of the possible values are scattered between

     * 0 and 0xfffffffffffff000.  Which leaves us with a gap between

     * the final two inputs that is twice as large as any other.

     */

    if (rate == 1.0) {

        *threshold = UINT64_MAX;

    } else {

        *threshold = (rate * 0xffff000000000000ull)

                   + (rate * 0x0000ffffffffffffull);

        *threshold = rate * 0x1p64;

    }

}