[v2,2/2] tests/qht-bench: Adjust threshold computation

Message ID 20200626200950.1015121-3-richard.henderson@linaro.org
State Superseded
Headers show
Series
  • tests/qht-bench: Adjust rate/threshold computation
Related show

Commit Message

Richard Henderson June 26, 2020, 8:09 p.m.
In 06c4cc3660b3, 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: Richard Henderson <richard.henderson@linaro.org>

---
 tests/qht-bench.c | 18 ++++++++++++++++--
 1 file changed, 16 insertions(+), 2 deletions(-)

-- 
2.25.1

Comments

Philippe Mathieu-Daudé June 26, 2020, 8:38 p.m. | #1
On 6/26/20 10:09 PM, Richard Henderson wrote:
> In 06c4cc3660b3, 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: Richard Henderson <richard.henderson@linaro.org>

> ---

>  tests/qht-bench.c | 18 ++++++++++++++++--

>  1 file changed, 16 insertions(+), 2 deletions(-)

> 

> diff --git a/tests/qht-bench.c b/tests/qht-bench.c

> index ad885d89d0..362f03cb03 100644

> --- a/tests/qht-bench.c

> +++ b/tests/qht-bench.c

> @@ -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;

>      }

>  }

>  

> 


Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>

Patch

diff --git a/tests/qht-bench.c b/tests/qht-bench.c
index ad885d89d0..362f03cb03 100644
--- a/tests/qht-bench.c
+++ b/tests/qht-bench.c
@@ -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;
     }
 }