mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-18 08:32:11 +01:00
std/softfloat: add bit-exact IEEE 754 binary64/binary32 arithmetic
Wuffs the Language has no floating point types, but some reference implementations (notably the brotli encoder) make decisions with double and float arithmetic and libm's log2. Porting them with byte-identical output needs bit-exact floating point results. This package implements f64 and f32 add, sub, mul, div, fma, comparisons, min/max, integer conversions and f64<->f32 conversions on bit patterns, with round-to-nearest-even, subnormals, infinities and NaNs, following the structure of Berkeley SoftFloat 3. It also ports glibc 2.39's x86-64 __log2_fma log2 implementation (the variant selected on CPUs with FMA and AVX2), following the shipped machine code's fused operations. Verification: test/c/std/softfloat.c checks every operation against the C compiler's native arithmetic on edge cases and random operands. The script/manual-test-softfloat-*.c programs run 10^8 random operations per operation group and compare log2_u64 against libm for every integer in [1, 2^32) plus 10^7 larger values; all with zero mismatches. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_011NoosQNe7DKWnqDCBeqw1p
This commit is contained in:
9 files changed
+26111
No files matched your search
@@ -0,0 +1,183 @@
|
||||
// Copyright 2026 The Wuffs Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
|
||||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
//
|
||||
// SPDX-License-Identifier: Apache-2.0 OR MIT
|
||||
|
||||
// ----------------
|
||||
|
||||
// manual-test-softfloat-log2.c checks that Wuffs' std/softfloat log2_u64(v)
|
||||
// function produces exactly the same bits as the C library's log2((double)v)
|
||||
// for EVERY v in [1, 1 << 32) and for 10 million pseudo-random v in [1 << 32,
|
||||
// 1 << 53). The softfloat implementation is a port of glibc's (x86-64, FMA)
|
||||
// log2, so this should only pass when linking against such a libm (e.g.
|
||||
// glibc 2.28 or later on an x86-64 CPU with FMA and AVX2). Run it with:
|
||||
//
|
||||
// gcc -O2 -std=c99 manual-test-softfloat-log2.c -lm -lpthread -o /tmp/sflog2
|
||||
// /tmp/sflog2
|
||||
//
|
||||
// An optional argument (e.g. "/tmp/sflog2 0x10000000") limits the exhaustive
|
||||
// part to v in [1, that). An optional second argument sets the number of
|
||||
// threads (default 4).
|
||||
//
|
||||
// It prints progress, the first 20 mismatches (if any) and exits with a
|
||||
// non-zero status if there were any mismatches.
|
||||
|
||||
#include <inttypes.h>
|
||||
#include <math.h>
|
||||
#include <pthread.h>
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <time.h>
|
||||
|
||||
#define WUFFS_IMPLEMENTATION
|
||||
#define WUFFS_CONFIG__STATIC_FUNCTIONS
|
||||
#define WUFFS_CONFIG__MODULES
|
||||
#define WUFFS_CONFIG__MODULE__BASE
|
||||
#define WUFFS_CONFIG__MODULE__SOFTFLOAT
|
||||
#include "../release/c/wuffs-unsupported-snapshot.c"
|
||||
|
||||
#define MAX_THREADS 64
|
||||
#define CHUNK_SIZE 0x1000000
|
||||
|
||||
static wuffs_softfloat__arith g_sf;
|
||||
static pthread_mutex_t g_mutex = PTHREAD_MUTEX_INITIALIZER;
|
||||
static uint64_t g_next_chunk = 1; // Guarded by g_mutex.
|
||||
static uint64_t g_end = 0;
|
||||
static uint64_t g_num_mismatches = 0; // Guarded by g_mutex.
|
||||
static uint64_t g_num_checked = 0; // Guarded by g_mutex.
|
||||
static time_t g_start_time;
|
||||
|
||||
static uint64_t //
|
||||
u_of_d(double d) {
|
||||
uint64_t u;
|
||||
memcpy(&u, &d, 8);
|
||||
return u;
|
||||
}
|
||||
|
||||
static void //
|
||||
report_mismatch(uint64_t v, uint64_t have, uint64_t want) {
|
||||
pthread_mutex_lock(&g_mutex);
|
||||
if (g_num_mismatches++ < 20) {
|
||||
printf("MISMATCH v=%" PRIu64 " (0x%" PRIX64 "): have 0x%016" PRIX64
|
||||
", want 0x%016" PRIX64 "\n",
|
||||
v, v, have, want);
|
||||
fflush(stdout);
|
||||
}
|
||||
pthread_mutex_unlock(&g_mutex);
|
||||
}
|
||||
|
||||
static void* //
|
||||
worker(void* arg) {
|
||||
(void)arg;
|
||||
while (1) {
|
||||
pthread_mutex_lock(&g_mutex);
|
||||
uint64_t lo = g_next_chunk;
|
||||
g_next_chunk = (lo + CHUNK_SIZE) & ~(uint64_t)(CHUNK_SIZE - 1);
|
||||
pthread_mutex_unlock(&g_mutex);
|
||||
if (lo >= g_end) {
|
||||
return NULL;
|
||||
}
|
||||
uint64_t hi = (lo + CHUNK_SIZE) & ~(uint64_t)(CHUNK_SIZE - 1);
|
||||
if (hi > g_end) {
|
||||
hi = g_end;
|
||||
}
|
||||
for (uint64_t v = lo; v < hi; v++) {
|
||||
uint64_t have = wuffs_softfloat__arith__log2_u64(&g_sf, v);
|
||||
uint64_t want = u_of_d(log2((double)v));
|
||||
if (have != want) {
|
||||
report_mismatch(v, have, want);
|
||||
}
|
||||
}
|
||||
pthread_mutex_lock(&g_mutex);
|
||||
g_num_checked += hi - lo;
|
||||
if ((hi % 0x10000000) == 0) {
|
||||
printf("progress: v up to 0x%09" PRIX64 " (%3d%%), %" PRIu64
|
||||
" mismatches so far, %ld seconds\n",
|
||||
hi, (int)((100 * hi) / g_end), g_num_mismatches,
|
||||
(long)(time(NULL) - g_start_time));
|
||||
fflush(stdout);
|
||||
}
|
||||
pthread_mutex_unlock(&g_mutex);
|
||||
}
|
||||
}
|
||||
|
||||
int //
|
||||
main(int argc, char** argv) {
|
||||
g_end = (argc > 1) ? strtoull(argv[1], NULL, 0) : 0x100000000ull;
|
||||
int num_threads = (argc > 2) ? atoi(argv[2]) : 4;
|
||||
if ((num_threads < 1) || (num_threads > MAX_THREADS)) {
|
||||
num_threads = 4;
|
||||
}
|
||||
|
||||
wuffs_base__status status = wuffs_softfloat__arith__initialize(
|
||||
&g_sf, sizeof g_sf, WUFFS_VERSION, 0);
|
||||
if (status.repr) {
|
||||
fprintf(stderr, "initialize: %s\n", status.repr);
|
||||
return 1;
|
||||
}
|
||||
|
||||
// Sanity check a few values.
|
||||
if ((wuffs_softfloat__arith__log2_u64(&g_sf, 0) != 0xFFF0000000000000ull) ||
|
||||
(wuffs_softfloat__arith__log2_u64(&g_sf, 1) != 0) ||
|
||||
(wuffs_softfloat__arith__log2_u64(&g_sf, 1024) !=
|
||||
0x4024000000000000ull)) {
|
||||
printf("FAIL: sanity check\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
// Exhaustive part.
|
||||
g_start_time = time(NULL);
|
||||
printf("exhaustive: v in [1, 0x%" PRIX64 "), %d threads\n", g_end,
|
||||
num_threads);
|
||||
fflush(stdout);
|
||||
pthread_t threads[MAX_THREADS];
|
||||
for (int i = 0; i < num_threads; i++) {
|
||||
pthread_create(&threads[i], NULL, worker, NULL);
|
||||
}
|
||||
for (int i = 0; i < num_threads; i++) {
|
||||
pthread_join(threads[i], NULL);
|
||||
}
|
||||
printf("exhaustive: %" PRIu64 " values checked, %" PRIu64
|
||||
" mismatches, %ld seconds\n",
|
||||
g_num_checked, g_num_mismatches, (long)(time(NULL) - g_start_time));
|
||||
|
||||
// Random part: v in [1 << 32, 1 << 53), with a deterministic xorshift64*
|
||||
// PRNG, half of them uniform in log scale (random bit length) and half
|
||||
// uniform.
|
||||
uint64_t rng = 0x9E3779B97F4A7C15ull;
|
||||
uint64_t num_random = 10000000;
|
||||
uint64_t random_mismatches = 0;
|
||||
for (uint64_t i = 0; i < num_random; i++) {
|
||||
rng ^= rng >> 12;
|
||||
rng ^= rng << 25;
|
||||
rng ^= rng >> 27;
|
||||
uint64_t r = rng * 0x2545F4914F6CDD1Dull;
|
||||
uint64_t v;
|
||||
if (i & 1) {
|
||||
v = (r >> 11) | (1ull << 32); // Uniform-ish in [1 << 32, 1 << 53).
|
||||
} else {
|
||||
int bits = 33 + (int)((r >> 58) % 21); // Bit length in [33, 53].
|
||||
v = (r & ((1ull << (bits - 1)) - 1)) | (1ull << (bits - 1));
|
||||
}
|
||||
uint64_t have = wuffs_softfloat__arith__log2_u64(&g_sf, v);
|
||||
uint64_t want = u_of_d(log2((double)v));
|
||||
if (have != want) {
|
||||
random_mismatches++;
|
||||
report_mismatch(v, have, want);
|
||||
}
|
||||
}
|
||||
printf("random: %" PRIu64 " values checked, %" PRIu64
|
||||
" mismatches, %ld seconds in total\n",
|
||||
num_random, random_mismatches, (long)(time(NULL) - g_start_time));
|
||||
|
||||
printf("%s: %" PRIu64 " mismatches in total\n",
|
||||
g_num_mismatches ? "FAIL" : "PASS", g_num_mismatches);
|
||||
return g_num_mismatches ? 1 : 0;
|
||||
}
|
||||
@@ -0,0 +1,689 @@
|
||||
// Copyright 2026 The Wuffs Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
|
||||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
//
|
||||
// SPDX-License-Identifier: Apache-2.0 OR MIT
|
||||
|
||||
// ----------------
|
||||
|
||||
// manual-test-softfloat-ops.c compares Wuffs' std/softfloat arithmetic
|
||||
// against the C compiler's native (hardware) double and float arithmetic (and
|
||||
// libm's fma and log2) for many pseudo-random operands.
|
||||
//
|
||||
// Build it WITHOUT -ffast-math and WITHOUT -mfma / -march=native (so that the
|
||||
// reference arithmetic is strict IEEE 754, with no FMA contraction):
|
||||
//
|
||||
// gcc -O2 -std=c99 manual-test-softfloat-ops.c -lm -o /tmp/sfops
|
||||
// /tmp/sfops # Default: 100 million operations per op.
|
||||
// /tmp/sfops 1000000 # Or pass the number of operations per op.
|
||||
// /tmp/sfops 1000000 f64_fma # Or test only the named op.
|
||||
//
|
||||
// It prints one line per op and the first few mismatches (if any), and exits
|
||||
// with a non-zero status if there were any mismatches. NaN results only need
|
||||
// to be NaN (on both sides): NaN payloads and signs are not compared.
|
||||
|
||||
#include <inttypes.h>
|
||||
#include <math.h>
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <time.h>
|
||||
|
||||
#define WUFFS_IMPLEMENTATION
|
||||
#define WUFFS_CONFIG__STATIC_FUNCTIONS
|
||||
#define WUFFS_CONFIG__MODULES
|
||||
#define WUFFS_CONFIG__MODULE__BASE
|
||||
#define WUFFS_CONFIG__MODULE__SOFTFLOAT
|
||||
#include "../release/c/wuffs-unsupported-snapshot.c"
|
||||
|
||||
#if defined(__FAST_MATH__) || defined(__FMA__)
|
||||
#error "Build without -ffast-math and without -mfma / -march=native"
|
||||
#endif
|
||||
|
||||
static wuffs_softfloat__arith g_sf;
|
||||
|
||||
// ---------------- Bit casts.
|
||||
|
||||
static double //
|
||||
d_of(uint64_t u) {
|
||||
double d;
|
||||
memcpy(&d, &u, 8);
|
||||
return d;
|
||||
}
|
||||
|
||||
static uint64_t //
|
||||
u_of_d(double d) {
|
||||
uint64_t u;
|
||||
memcpy(&u, &d, 8);
|
||||
return u;
|
||||
}
|
||||
|
||||
static float //
|
||||
f_of(uint32_t u) {
|
||||
float f;
|
||||
memcpy(&f, &u, 4);
|
||||
return f;
|
||||
}
|
||||
|
||||
static uint32_t //
|
||||
u_of_f(float f) {
|
||||
uint32_t u;
|
||||
memcpy(&u, &f, 4);
|
||||
return u;
|
||||
}
|
||||
|
||||
// ---------------- PRNG (xorshift64*).
|
||||
|
||||
static uint64_t g_rng = 0x2545F4914F6CDD1Dull;
|
||||
|
||||
static uint64_t //
|
||||
rnd() {
|
||||
g_rng ^= g_rng >> 12;
|
||||
g_rng ^= g_rng << 25;
|
||||
g_rng ^= g_rng >> 27;
|
||||
return g_rng * 0x2545F4914F6CDD1Dull;
|
||||
}
|
||||
|
||||
// ---------------- Operand generators.
|
||||
|
||||
static const uint64_t g_f64_edges[] = {
|
||||
0x0000000000000000ull, // +0
|
||||
0x8000000000000000ull, // -0
|
||||
0x0000000000000001ull, // min subnormal
|
||||
0x8000000000000001ull, //
|
||||
0x000FFFFFFFFFFFFFull, // max subnormal
|
||||
0x800FFFFFFFFFFFFFull, //
|
||||
0x0010000000000000ull, // min normal
|
||||
0x8010000000000000ull, //
|
||||
0x3FF0000000000000ull, // 1
|
||||
0xBFF0000000000000ull, // -1
|
||||
0x7FEFFFFFFFFFFFFFull, // max
|
||||
0xFFEFFFFFFFFFFFFFull, //
|
||||
0x7FF0000000000000ull, // +inf
|
||||
0xFFF0000000000000ull, // -inf
|
||||
0x7FF8000000000000ull, // qNaN
|
||||
0x7FF0000000000001ull, // sNaN
|
||||
0x3FE0000000000000ull, // 0.5
|
||||
0x4000000000000000ull, // 2
|
||||
0x3CA0000000000000ull, // 2**-53
|
||||
0x4340000000000000ull, // 2**53
|
||||
0x43F0000000000000ull, // 2**64
|
||||
0x7FE0000000000000ull, // 2**1023
|
||||
0x0020000000000000ull, // 2**-1021
|
||||
0x3FEFFFFFFFFFFFFFull, // 1 - ulp
|
||||
0x3FF0000000000001ull, // 1 + ulp
|
||||
};
|
||||
|
||||
static const uint32_t g_f32_edges[] = {
|
||||
0x00000000u, 0x80000000u, 0x00000001u, 0x80000001u, 0x007FFFFFu,
|
||||
0x807FFFFFu, 0x00800000u, 0x80800000u, 0x3F800000u, 0xBF800000u,
|
||||
0x7F7FFFFFu, 0xFF7FFFFFu, 0x7F800000u, 0xFF800000u, 0x7FC00000u,
|
||||
0x7F800001u, 0x3F000000u, 0x40000000u, 0x33800000u, 0x4B800000u,
|
||||
0x7EFFC99Eu, 0x3F7FFFFFu, 0x3F800001u,
|
||||
};
|
||||
|
||||
#define N_F64_EDGES (sizeof(g_f64_edges) / sizeof(g_f64_edges[0]))
|
||||
#define N_F32_EDGES (sizeof(g_f32_edges) / sizeof(g_f32_edges[0]))
|
||||
|
||||
// gen_frac returns 52 fraction bits, biased towards patterns that produce
|
||||
// exact results and ties (few set bits, all bits set) as well as random ones.
|
||||
static uint64_t //
|
||||
gen_frac() {
|
||||
uint64_t r = rnd();
|
||||
switch (rnd() & 7) {
|
||||
case 0: // Only the top few bits set.
|
||||
return r & (0x000FFFFFFFFFFFFFull << (40 + (rnd() % 13))) &
|
||||
0x000FFFFFFFFFFFFFull;
|
||||
case 1: // Only the bottom few bits set.
|
||||
return r & ((1ull << (rnd() % 13)) - 1);
|
||||
case 2: // Nearly all bits set.
|
||||
return 0x000FFFFFFFFFFFFFull ^ (r & ((1ull << (rnd() % 13)) - 1));
|
||||
case 3: // Sparse.
|
||||
return r & rnd() & rnd() & 0x000FFFFFFFFFFFFFull;
|
||||
}
|
||||
return r & 0x000FFFFFFFFFFFFFull;
|
||||
}
|
||||
|
||||
static uint64_t //
|
||||
gen_f64() {
|
||||
uint64_t sign = (rnd() & 1) << 63;
|
||||
uint64_t exp;
|
||||
switch (rnd() & 15) {
|
||||
case 0:
|
||||
return rnd();
|
||||
case 1:
|
||||
return g_f64_edges[rnd() % N_F64_EDGES];
|
||||
case 2: // Subnormal or tiny.
|
||||
exp = rnd() % 3;
|
||||
break;
|
||||
case 3: // Huge.
|
||||
exp = 0x7FC + (rnd() % 4);
|
||||
break;
|
||||
case 4: // Moderate.
|
||||
exp = 0x3F0 + (rnd() % 0x20);
|
||||
break;
|
||||
case 5: // Small integers.
|
||||
return sign | u_of_d((double)(rnd() % 2000));
|
||||
case 6: // Just above or below the f32 range boundaries.
|
||||
exp = (rnd() & 1) ? (0x47E + (rnd() % 3)) : (0x368 + (rnd() % 0x1A));
|
||||
break;
|
||||
default:
|
||||
exp = 1 + (rnd() % 0x7FE);
|
||||
break;
|
||||
}
|
||||
return sign | (exp << 52) | gen_frac();
|
||||
}
|
||||
|
||||
// gen_f64_near returns an f64 related to a: with a nearby exponent, or a few
|
||||
// ULPs away, or a simple multiple, so that add/sub/div exercise cancellation,
|
||||
// alignment and exact results.
|
||||
static uint64_t //
|
||||
gen_f64_near(uint64_t a) {
|
||||
uint64_t sign = (rnd() & 1) << 63;
|
||||
switch (rnd() & 7) {
|
||||
case 0:
|
||||
case 1: {
|
||||
int64_t exp = (int64_t)((a >> 52) & 0x7FF) + (int64_t)(rnd() % 121) - 60;
|
||||
if (exp < 0) {
|
||||
exp = 0;
|
||||
} else if (exp > 0x7FE) {
|
||||
exp = 0x7FE;
|
||||
}
|
||||
return sign | ((uint64_t)exp << 52) | gen_frac();
|
||||
}
|
||||
case 2:
|
||||
return (a + (rnd() % 9) - 4) ^ sign;
|
||||
case 3:
|
||||
return u_of_d(d_of(a) * (double)(rnd() % 20)) ^ sign;
|
||||
}
|
||||
return gen_f64();
|
||||
}
|
||||
|
||||
static uint32_t //
|
||||
gen_f32() {
|
||||
uint32_t sign = (uint32_t)(rnd() & 1) << 31;
|
||||
uint32_t exp;
|
||||
uint32_t frac = (uint32_t)(gen_frac() >> 29);
|
||||
switch (rnd() & 15) {
|
||||
case 0:
|
||||
return (uint32_t)rnd();
|
||||
case 1:
|
||||
return g_f32_edges[rnd() % N_F32_EDGES];
|
||||
case 2:
|
||||
exp = (uint32_t)(rnd() % 3);
|
||||
break;
|
||||
case 3:
|
||||
exp = 0xFC + (uint32_t)(rnd() % 4);
|
||||
break;
|
||||
case 4:
|
||||
exp = 0x70 + (uint32_t)(rnd() % 0x20);
|
||||
break;
|
||||
case 5:
|
||||
return sign | u_of_f((float)(rnd() % 2000));
|
||||
default:
|
||||
exp = 1 + (uint32_t)(rnd() % 0xFE);
|
||||
break;
|
||||
}
|
||||
return sign | (exp << 23) | frac;
|
||||
}
|
||||
|
||||
static uint32_t //
|
||||
gen_f32_near(uint32_t a) {
|
||||
uint32_t sign = (uint32_t)(rnd() & 1) << 31;
|
||||
switch (rnd() & 7) {
|
||||
case 0:
|
||||
case 1: {
|
||||
int32_t exp = (int32_t)((a >> 23) & 0xFF) + (int32_t)(rnd() % 61) - 30;
|
||||
if (exp < 0) {
|
||||
exp = 0;
|
||||
} else if (exp > 0xFE) {
|
||||
exp = 0xFE;
|
||||
}
|
||||
return sign | ((uint32_t)exp << 23) | (uint32_t)(gen_frac() >> 29);
|
||||
}
|
||||
case 2:
|
||||
return (a + (uint32_t)(rnd() % 9) - 4) ^ sign;
|
||||
}
|
||||
return gen_f32();
|
||||
}
|
||||
|
||||
static uint64_t //
|
||||
gen_u64() {
|
||||
uint64_t r = rnd();
|
||||
switch (rnd() & 3) {
|
||||
case 0:
|
||||
return r;
|
||||
case 1:
|
||||
return r >> (rnd() % 64);
|
||||
case 2: // Near a power of 2, or with few bits.
|
||||
return (r & rnd() & rnd()) >> (rnd() % 64);
|
||||
}
|
||||
return ((1ull << (rnd() % 64)) + (rnd() % 5) - 2);
|
||||
}
|
||||
|
||||
// ---------------- Checks.
|
||||
|
||||
static uint64_t g_num_mismatches = 0;
|
||||
static uint64_t g_op_mismatches = 0;
|
||||
|
||||
static bool //
|
||||
same64(uint64_t have, uint64_t want) {
|
||||
if (isnan(d_of(want))) {
|
||||
return isnan(d_of(have));
|
||||
}
|
||||
return have == want;
|
||||
}
|
||||
|
||||
static bool //
|
||||
same32(uint32_t have, uint32_t want) {
|
||||
if (isnan(f_of(want))) {
|
||||
return isnan(f_of(have));
|
||||
}
|
||||
return have == want;
|
||||
}
|
||||
|
||||
static void //
|
||||
mismatch3(const char* op,
|
||||
uint64_t a,
|
||||
uint64_t b,
|
||||
uint64_t c,
|
||||
uint64_t have,
|
||||
uint64_t want) {
|
||||
g_num_mismatches++;
|
||||
if (g_op_mismatches++ < 10) {
|
||||
printf(" MISMATCH %s(0x%016" PRIX64 ", 0x%016" PRIX64 ", 0x%016" PRIX64
|
||||
"): have 0x%016" PRIX64 ", want 0x%016" PRIX64 "\n",
|
||||
op, a, b, c, have, want);
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------- Per-op test loops.
|
||||
|
||||
typedef void (*test_func)(uint64_t n);
|
||||
|
||||
#define LOOP_F64_BINOP(name, expr_have, expr_want) \
|
||||
static void test_##name(uint64_t n) { \
|
||||
for (uint64_t i = 0; i < n; i++) { \
|
||||
uint64_t a = gen_f64(); \
|
||||
uint64_t b = (rnd() & 1) ? gen_f64_near(a) : gen_f64(); \
|
||||
if (rnd() & 1) { \
|
||||
uint64_t t = a; \
|
||||
a = b; \
|
||||
b = t; \
|
||||
} \
|
||||
uint64_t have = (expr_have); \
|
||||
uint64_t want = (expr_want); \
|
||||
if (!same64(have, want)) { \
|
||||
mismatch3(#name, a, b, 0, have, want); \
|
||||
} \
|
||||
} \
|
||||
}
|
||||
|
||||
#define LOOP_F32_BINOP(name, expr_have, expr_want) \
|
||||
static void test_##name(uint64_t n) { \
|
||||
for (uint64_t i = 0; i < n; i++) { \
|
||||
uint32_t a = gen_f32(); \
|
||||
uint32_t b = (rnd() & 1) ? gen_f32_near(a) : gen_f32(); \
|
||||
if (rnd() & 1) { \
|
||||
uint32_t t = a; \
|
||||
a = b; \
|
||||
b = t; \
|
||||
} \
|
||||
uint32_t have = (expr_have); \
|
||||
uint32_t want = (expr_want); \
|
||||
if (!same32(have, want)) { \
|
||||
mismatch3(#name, a, b, 0, have, want); \
|
||||
} \
|
||||
} \
|
||||
}
|
||||
|
||||
#define SF(f) wuffs_softfloat__arith__##f
|
||||
|
||||
LOOP_F64_BINOP(f64_add,
|
||||
SF(f64_add)(&g_sf, a, b),
|
||||
u_of_d(d_of(a) + d_of(b)))
|
||||
LOOP_F64_BINOP(f64_sub,
|
||||
SF(f64_sub)(&g_sf, a, b),
|
||||
u_of_d(d_of(a) - d_of(b)))
|
||||
LOOP_F64_BINOP(f64_mul,
|
||||
SF(f64_mul)(&g_sf, a, b),
|
||||
u_of_d(d_of(a) * d_of(b)))
|
||||
LOOP_F64_BINOP(f64_div,
|
||||
SF(f64_div)(&g_sf, a, b),
|
||||
u_of_d(d_of(a) / d_of(b)))
|
||||
LOOP_F64_BINOP(f64_cmp,
|
||||
SF(f64_cmp)(&g_sf, a, b),
|
||||
(isnan(d_of(a)) || isnan(d_of(b)))
|
||||
? 3
|
||||
: ((d_of(a) < d_of(b)) ? 0 : (d_of(a) == d_of(b)) ? 1 : 2))
|
||||
LOOP_F64_BINOP(f64_predicates,
|
||||
(SF(f64_eq)(&g_sf, a, b) << 0) |
|
||||
(SF(f64_ne)(&g_sf, a, b) << 1) |
|
||||
(SF(f64_lt)(&g_sf, a, b) << 2) |
|
||||
(SF(f64_le)(&g_sf, a, b) << 3) |
|
||||
(SF(f64_gt)(&g_sf, a, b) << 4) |
|
||||
(SF(f64_ge)(&g_sf, a, b) << 5),
|
||||
((uint64_t)(d_of(a) == d_of(b)) << 0) |
|
||||
((uint64_t)(d_of(a) != d_of(b)) << 1) |
|
||||
((uint64_t)(d_of(a) < d_of(b)) << 2) |
|
||||
((uint64_t)(d_of(a) <= d_of(b)) << 3) |
|
||||
((uint64_t)(d_of(a) > d_of(b)) << 4) |
|
||||
((uint64_t)(d_of(a) >= d_of(b)) << 5))
|
||||
// min and max are compared bit-exactly (including NaN payloads), since they
|
||||
// just select one of their arguments.
|
||||
LOOP_F64_BINOP(f64_min_max,
|
||||
SF(f64_min)(&g_sf, a, b) ^ (SF(f64_max)(&g_sf, a, b) * 3),
|
||||
u_of_d((d_of(a) < d_of(b)) ? d_of(a) : d_of(b)) ^
|
||||
(u_of_d((d_of(a) > d_of(b)) ? d_of(a) : d_of(b)) * 3))
|
||||
|
||||
LOOP_F32_BINOP(f32_add,
|
||||
SF(f32_add)(&g_sf, a, b),
|
||||
u_of_f(f_of(a) + f_of(b)))
|
||||
LOOP_F32_BINOP(f32_sub,
|
||||
SF(f32_sub)(&g_sf, a, b),
|
||||
u_of_f(f_of(a) - f_of(b)))
|
||||
LOOP_F32_BINOP(f32_mul,
|
||||
SF(f32_mul)(&g_sf, a, b),
|
||||
u_of_f(f_of(a) * f_of(b)))
|
||||
LOOP_F32_BINOP(f32_div,
|
||||
SF(f32_div)(&g_sf, a, b),
|
||||
u_of_f(f_of(a) / f_of(b)))
|
||||
LOOP_F32_BINOP(f32_cmp,
|
||||
SF(f32_cmp)(&g_sf, a, b),
|
||||
(isnan(f_of(a)) || isnan(f_of(b)))
|
||||
? 3
|
||||
: ((f_of(a) < f_of(b)) ? 0 : (f_of(a) == f_of(b)) ? 1 : 2))
|
||||
LOOP_F32_BINOP(f32_predicates,
|
||||
(SF(f32_eq)(&g_sf, a, b) << 0) |
|
||||
(SF(f32_ne)(&g_sf, a, b) << 1) |
|
||||
(SF(f32_lt)(&g_sf, a, b) << 2) |
|
||||
(SF(f32_le)(&g_sf, a, b) << 3) |
|
||||
(SF(f32_gt)(&g_sf, a, b) << 4) |
|
||||
(SF(f32_ge)(&g_sf, a, b) << 5),
|
||||
((uint32_t)(f_of(a) == f_of(b)) << 0) |
|
||||
((uint32_t)(f_of(a) != f_of(b)) << 1) |
|
||||
((uint32_t)(f_of(a) < f_of(b)) << 2) |
|
||||
((uint32_t)(f_of(a) <= f_of(b)) << 3) |
|
||||
((uint32_t)(f_of(a) > f_of(b)) << 4) |
|
||||
((uint32_t)(f_of(a) >= f_of(b)) << 5))
|
||||
LOOP_F32_BINOP(f32_min_max,
|
||||
SF(f32_min)(&g_sf, a, b) ^ (SF(f32_max)(&g_sf, a, b) * 3),
|
||||
u_of_f((f_of(a) < f_of(b)) ? f_of(a) : f_of(b)) ^
|
||||
(u_of_f((f_of(a) > f_of(b)) ? f_of(a) : f_of(b)) * 3))
|
||||
|
||||
static void //
|
||||
test_f64_fma(uint64_t n) {
|
||||
for (uint64_t i = 0; i < n; i++) {
|
||||
uint64_t a = gen_f64();
|
||||
uint64_t b = (rnd() & 1) ? gen_f64_near(a) : gen_f64();
|
||||
uint64_t c;
|
||||
switch (rnd() & 3) {
|
||||
case 0: // c is near (a * b), for cancellation.
|
||||
c = u_of_d(-(d_of(a) * d_of(b)));
|
||||
c = (rnd() & 1) ? (c + (rnd() % 5) - 2) : gen_f64_near(c);
|
||||
break;
|
||||
case 1:
|
||||
c = gen_f64_near(a);
|
||||
break;
|
||||
default:
|
||||
c = gen_f64();
|
||||
break;
|
||||
}
|
||||
uint64_t have = SF(f64_fma)(&g_sf, a, b, c);
|
||||
uint64_t want = u_of_d(fma(d_of(a), d_of(b), d_of(c)));
|
||||
if (!same64(have, want)) {
|
||||
mismatch3("f64_fma", a, b, c, have, want);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void //
|
||||
test_f64_conversions(uint64_t n) {
|
||||
for (uint64_t i = 0; i < n; i++) {
|
||||
uint64_t u = gen_u64();
|
||||
uint64_t have = SF(f64_from_u64)(&g_sf, u);
|
||||
uint64_t want = u_of_d((double)u);
|
||||
if (!same64(have, want)) {
|
||||
mismatch3("f64_from_u64", u, 0, 0, have, want);
|
||||
}
|
||||
|
||||
have = SF(f64_from_u32)(&g_sf, (uint32_t)u);
|
||||
want = u_of_d((double)(uint32_t)u);
|
||||
if (!same64(have, want)) {
|
||||
mismatch3("f64_from_u32", (uint32_t)u, 0, 0, have, want);
|
||||
}
|
||||
|
||||
have = SF(f64_from_i64)(&g_sf, (int64_t)u);
|
||||
want = u_of_d((double)(int64_t)u);
|
||||
if (!same64(have, want)) {
|
||||
mismatch3("f64_from_i64", u, 0, 0, have, want);
|
||||
}
|
||||
|
||||
uint64_t x = gen_f64();
|
||||
double dx = d_of(x);
|
||||
if ((dx > -1.0) && (dx < 18446744073709551616.0)) {
|
||||
have = SF(f64_to_u64_trunc)(&g_sf, x);
|
||||
want = (uint64_t)dx;
|
||||
if (have != want) {
|
||||
mismatch3("f64_to_u64_trunc", x, 0, 0, have, want);
|
||||
}
|
||||
}
|
||||
// Also exercise (size_t)(x + 0.5) for x in [0, 64), as in brotli's
|
||||
// bit_cost_inc.h.
|
||||
x = u_of_d(d_of((rnd() & 0x000FFFFFFFFFFFFFull) | 0x3FF0000000000000ull) *
|
||||
(double)(1 << (rnd() % 6)) -
|
||||
1.0);
|
||||
have = SF(f64_to_u64_trunc)(&g_sf,
|
||||
SF(f64_add)(&g_sf, x, 0x3FE0000000000000ull));
|
||||
want = (uint64_t)(d_of(x) + 0.5);
|
||||
if (have != want) {
|
||||
mismatch3("f64_to_u64_trunc(x + 0.5)", x, 0, 0, have, want);
|
||||
}
|
||||
|
||||
have = SF(f64_to_f32)(&g_sf, x = gen_f64());
|
||||
want = u_of_f((float)d_of(x));
|
||||
if (!same32((uint32_t)have, (uint32_t)want)) {
|
||||
mismatch3("f64_to_f32", x, 0, 0, have, want);
|
||||
}
|
||||
|
||||
uint32_t f = gen_f32();
|
||||
have = SF(f32_to_f64)(&g_sf, f);
|
||||
want = u_of_d((double)f_of(f));
|
||||
if (!same64(have, want)) {
|
||||
mismatch3("f32_to_f64", f, 0, 0, have, want);
|
||||
}
|
||||
|
||||
have = SF(f32_from_u32)(&g_sf, (uint32_t)u);
|
||||
want = u_of_f((float)(uint32_t)u);
|
||||
if (have != want) {
|
||||
mismatch3("f32_from_u32", (uint32_t)u, 0, 0, have, want);
|
||||
}
|
||||
|
||||
have = SF(f32_from_i32)(&g_sf, (int32_t)u);
|
||||
want = u_of_f((float)(int32_t)u);
|
||||
if (have != want) {
|
||||
mismatch3("f32_from_i32", (uint32_t)u, 0, 0, have, want);
|
||||
}
|
||||
|
||||
have = SF(f32_from_u64)(&g_sf, u);
|
||||
want = u_of_f((float)u);
|
||||
if (have != want) {
|
||||
mismatch3("f32_from_u64", u, 0, 0, have, want);
|
||||
}
|
||||
|
||||
uint64_t n = rnd() >> (rnd() & 63);
|
||||
have = SF(f64_neg)(&g_sf, n) ^ (SF(f64_abs)(&g_sf, n) * 3) ^
|
||||
((uint64_t)SF(f64_is_nan)(&g_sf, n) << 7);
|
||||
want = u_of_d(-d_of(n)) ^ (u_of_d(fabs(d_of(n))) * 3) ^
|
||||
((uint64_t)(isnan(d_of(n)) ? 1 : 0) << 7);
|
||||
if (have != want) {
|
||||
mismatch3("f64_neg_abs_is_nan", n, 0, 0, have, want);
|
||||
}
|
||||
uint32_t m = (uint32_t)n;
|
||||
have = SF(f32_neg)(&g_sf, m) ^ (SF(f32_abs)(&g_sf, m) * 3) ^
|
||||
((uint32_t)SF(f32_is_nan)(&g_sf, m) << 7);
|
||||
want = u_of_f(-f_of(m)) ^ (u_of_f(fabsf(f_of(m))) * 3) ^
|
||||
((uint32_t)(isnan(f_of(m)) ? 1 : 0) << 7);
|
||||
if (have != want) {
|
||||
mismatch3("f32_neg_abs_is_nan", m, 0, 0, have, want);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Brotli-specific patterns: (float)FastLog2(n) + 2, log2sum - (float)x,
|
||||
// (float)lit_cost and similar.
|
||||
static void //
|
||||
test_brotli_patterns(uint64_t n) {
|
||||
for (uint64_t i = 0; i < n; i++) {
|
||||
uint64_t v = (rnd() >> (rnd() % 64)) | 1;
|
||||
double lg = log2((double)v);
|
||||
uint64_t lg_have = SF(log2_u64)(&g_sf, v);
|
||||
if (lg_have != u_of_d(lg)) {
|
||||
mismatch3("log2_u64", v, 0, 0, lg_have, u_of_d(lg));
|
||||
}
|
||||
uint32_t have =
|
||||
SF(f32_add)(&g_sf, SF(f64_to_f32)(&g_sf, lg_have), 0x40000000u);
|
||||
uint32_t want = u_of_f((float)lg + 2);
|
||||
if (have != want) {
|
||||
mismatch3("(float)FastLog2(n) + 2", v, 0, 0, have, want);
|
||||
}
|
||||
uint64_t w = (rnd() >> (rnd() % 64)) | 1;
|
||||
double lw = log2((double)w);
|
||||
have = SF(f32_sub)(&g_sf, SF(f64_to_f32)(&g_sf, lg_have),
|
||||
SF(f64_to_f32)(&g_sf, u_of_d(lw)));
|
||||
want = u_of_f((float)lg - (float)lw);
|
||||
if (have != want) {
|
||||
mismatch3("(float)log2(v) - (float)log2(w)", v, w, 0, have, want);
|
||||
}
|
||||
// lit_cost = log2(v) - log2(w); lit_cost += 0.029; if (lit_cost < 1.0)
|
||||
// { lit_cost *= 0.5; lit_cost += 0.5; } ... (float)lit_cost.
|
||||
double lc = lg - lw;
|
||||
lc += 0.029;
|
||||
if (lc < 1.0) {
|
||||
lc *= 0.5;
|
||||
lc += 0.5;
|
||||
}
|
||||
lc += 0.35 + (0.35 / 2000) * (double)(i % 2000);
|
||||
uint64_t sc = SF(f64_sub)(&g_sf, lg_have, u_of_d(lw));
|
||||
sc = SF(f64_add)(&g_sf, sc, u_of_d(0.029));
|
||||
if (SF(f64_lt)(&g_sf, sc, u_of_d(1.0))) {
|
||||
sc = SF(f64_mul)(&g_sf, sc, u_of_d(0.5));
|
||||
sc = SF(f64_add)(&g_sf, sc, u_of_d(0.5));
|
||||
}
|
||||
sc = SF(f64_add)(
|
||||
&g_sf, sc,
|
||||
SF(f64_add)(&g_sf, u_of_d(0.35),
|
||||
SF(f64_mul)(&g_sf, u_of_d(0.35 / 2000),
|
||||
SF(f64_from_u64)(&g_sf, i % 2000))));
|
||||
if (SF(f64_to_f32)(&g_sf, sc) != u_of_f((float)lc)) {
|
||||
mismatch3("lit_cost", v, w, i, SF(f64_to_f32)(&g_sf, sc),
|
||||
u_of_f((float)lc));
|
||||
}
|
||||
// (size_t)(log2p + 0.5) and bits += data * log2p.
|
||||
double log2p = lw - lg;
|
||||
uint64_t s_log2p = SF(f64_sub)(&g_sf, u_of_d(lw), lg_have);
|
||||
if (log2p >= 0) {
|
||||
if (SF(f64_to_u64_trunc)(&g_sf, SF(f64_add)(&g_sf, s_log2p,
|
||||
u_of_d(0.5))) !=
|
||||
(uint64_t)(log2p + 0.5)) {
|
||||
mismatch3("(size_t)(log2p + 0.5)", v, w, 0, 0, 0);
|
||||
}
|
||||
}
|
||||
uint32_t cnt = (uint32_t)rnd();
|
||||
if (SF(f64_mul)(&g_sf, SF(f64_from_u32)(&g_sf, cnt), s_log2p) !=
|
||||
u_of_d(cnt * log2p)) {
|
||||
mismatch3("data * log2p", v, w, cnt, 0, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void //
|
||||
test_log2_f64(uint64_t n) {
|
||||
for (uint64_t i = 0; i < n; i++) {
|
||||
uint64_t x;
|
||||
switch (rnd() & 3) {
|
||||
case 0: // Near 1.0.
|
||||
x = 0x3FF0000000000000ull + (rnd() % 0x0001000000000000ull) -
|
||||
0x0000800000000000ull;
|
||||
break;
|
||||
case 1: // Positive.
|
||||
x = gen_f64() & 0x7FFFFFFFFFFFFFFFull;
|
||||
break;
|
||||
default:
|
||||
x = gen_f64();
|
||||
break;
|
||||
}
|
||||
uint64_t have = SF(log2_f64)(&g_sf, x);
|
||||
uint64_t want = u_of_d(log2(d_of(x)));
|
||||
if (!same64(have, want)) {
|
||||
mismatch3("log2_f64", x, 0, 0, have, want);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------- Main.
|
||||
|
||||
static struct {
|
||||
const char* name;
|
||||
test_func func;
|
||||
uint64_t scale; // Divides the number of operations.
|
||||
} g_ops[] = {
|
||||
{"f64_add", test_f64_add, 1},
|
||||
{"f64_sub", test_f64_sub, 1},
|
||||
{"f64_mul", test_f64_mul, 1},
|
||||
{"f64_div", test_f64_div, 1},
|
||||
{"f64_fma", test_f64_fma, 1},
|
||||
{"f64_cmp", test_f64_cmp, 1},
|
||||
{"f64_predicates", test_f64_predicates, 1},
|
||||
{"f64_min_max", test_f64_min_max, 1},
|
||||
{"f32_add", test_f32_add, 1},
|
||||
{"f32_sub", test_f32_sub, 1},
|
||||
{"f32_mul", test_f32_mul, 1},
|
||||
{"f32_div", test_f32_div, 1},
|
||||
{"f32_cmp", test_f32_cmp, 1},
|
||||
{"f32_predicates", test_f32_predicates, 1},
|
||||
{"f32_min_max", test_f32_min_max, 1},
|
||||
{"conversions", test_f64_conversions, 1},
|
||||
{"brotli_patterns", test_brotli_patterns, 4},
|
||||
{"log2_f64", test_log2_f64, 4},
|
||||
};
|
||||
|
||||
int //
|
||||
main(int argc, char** argv) {
|
||||
uint64_t n = 100000000;
|
||||
if (argc > 1) {
|
||||
n = strtoull(argv[1], NULL, 10);
|
||||
}
|
||||
const char* only = (argc > 2) ? argv[2] : NULL;
|
||||
|
||||
wuffs_base__status status = wuffs_softfloat__arith__initialize(
|
||||
&g_sf, sizeof g_sf, WUFFS_VERSION, 0);
|
||||
if (status.repr) {
|
||||
fprintf(stderr, "initialize: %s\n", status.repr);
|
||||
return 1;
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < sizeof(g_ops) / sizeof(g_ops[0]); i++) {
|
||||
if (only && strcmp(only, g_ops[i].name)) {
|
||||
continue;
|
||||
}
|
||||
uint64_t m = n / g_ops[i].scale;
|
||||
g_op_mismatches = 0;
|
||||
clock_t t0 = clock();
|
||||
(*g_ops[i].func)(m);
|
||||
double secs = (double)(clock() - t0) / CLOCKS_PER_SEC;
|
||||
printf("%-16s %12" PRIu64 " iterations, %8" PRIu64
|
||||
" mismatches, %7.1f seconds\n",
|
||||
g_ops[i].name, m, g_op_mismatches, secs);
|
||||
fflush(stdout);
|
||||
}
|
||||
printf("%s: %" PRIu64 " mismatches in total\n",
|
||||
g_num_mismatches ? "FAIL" : "PASS", g_num_mismatches);
|
||||
return g_num_mismatches ? 1 : 0;
|
||||
}
|
||||
Reference in new issue
Block a user