mirror of
https://github.com/postgres/postgres.git
synced 2025-05-11 05:41:32 +03:00
02ddd49932
Previously, floating-point output was done by rounding to a specific decimal precision; by default, to 6 or 15 decimal digits (losing information) or as requested using extra_float_digits. Drivers that wanted exact float values, and applications like pg_dump that must preserve values exactly, set extra_float_digits=3 (or sometimes 2 for historical reasons, though this isn't enough for float4). Unfortunately, decimal rounded output is slow enough to become a noticable bottleneck when dealing with large result sets or COPY of large tables when many floating-point values are involved. Floating-point output can be done much faster when the output is not rounded to a specific decimal length, but rather is chosen as the shortest decimal representation that is closer to the original float value than to any other value representable in the same precision. The recently published Ryu algorithm by Ulf Adams is both relatively simple and remarkably fast. Accordingly, change float4out/float8out to output shortest decimal representations if extra_float_digits is greater than 0, and make that the new default. Applications that need rounded output can set extra_float_digits back to 0 or below, and take the resulting performance hit. We make one concession to portability for systems with buggy floating-point input: we do not output decimal values that fall exactly halfway between adjacent representable binary values (which would rely on the reader doing round-to-nearest-even correctly). This is known to be a problem at least for VS2013 on Windows. Our version of the Ryu code originates from https://github.com/ulfjack/ryu/ at commit c9c3fb1979, but with the following (significant) modifications: - Output format is changed to use fixed-point notation for small exponents, as printf would, and also to use lowercase 'e', a minimum of 2 exponent digits, and a mandatory sign on the exponent, to keep the formatting as close as possible to previous output. - The output of exact midpoint values is disabled as noted above. - The integer fast-path code is changed somewhat (since we have fixed-point output and the upstream did not). - Our project style has been largely applied to the code with the exception of C99 declaration-after-statement, which has been retained as an exception to our present policy. - Most of upstream's debugging and conditionals are removed, and we use our own configure tests to determine things like uint128 availability. Changing the float output format obviously affects a number of regression tests. This patch uses an explicit setting of extra_float_digits=0 for test output that is not expected to be exactly reproducible (e.g. due to numerical instability or differing algorithms for transcendental functions). Conversions from floats to numeric are unchanged by this patch. These may appear in index expressions and it is not yet clear whether any change should be made, so that can be left for another day. This patch assumes that the only supported floating point format is now IEEE format, and the documentation is updated to reflect that. Code by me, adapting the work of Ulf Adams and other contributors. References: https://dl.acm.org/citation.cfm?id=3192369 Reviewed-by: Tom Lane, Andres Freund, Donald Dong Discussion: https://postgr.es/m/87r2el1bx6.fsf@news-spur.riddles.org.uk
134 lines
3.2 KiB
C
134 lines
3.2 KiB
C
/*---------------------------------------------------------------------------
|
|
*
|
|
* Common routines for Ryu floating-point output.
|
|
*
|
|
* Portions Copyright (c) 2018-2019, PostgreSQL Global Development Group
|
|
*
|
|
* IDENTIFICATION
|
|
* src/common/ryu_common.h
|
|
*
|
|
* This is a modification of code taken from github.com/ulfjack/ryu under the
|
|
* terms of the Boost license (not the Apache license). The original copyright
|
|
* notice follows:
|
|
*
|
|
* Copyright 2018 Ulf Adams
|
|
*
|
|
* The contents of this file may be used under the terms of the Apache
|
|
* License, Version 2.0.
|
|
*
|
|
* (See accompanying file LICENSE-Apache or copy at
|
|
* http://www.apache.org/licenses/LICENSE-2.0)
|
|
*
|
|
* Alternatively, the contents of this file may be used under the terms of the
|
|
* Boost Software License, Version 1.0.
|
|
*
|
|
* (See accompanying file LICENSE-Boost or copy at
|
|
* https://www.boost.org/LICENSE_1_0.txt)
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, this software is
|
|
* distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
* KIND, either express or implied.
|
|
*
|
|
*---------------------------------------------------------------------------
|
|
*/
|
|
#ifndef RYU_COMMON_H
|
|
#define RYU_COMMON_H
|
|
|
|
/*
|
|
* Upstream Ryu's output is always the shortest possible. But we adjust that
|
|
* slightly to improve portability: we avoid outputting the exact midpoint
|
|
* value between two representable floats, since that relies on the reader
|
|
* getting the round-to-even rule correct, which seems to be the common
|
|
* failure mode.
|
|
*
|
|
* Defining this to 1 would restore the upstream behavior.
|
|
*/
|
|
#define STRICTLY_SHORTEST 0
|
|
|
|
#if SIZEOF_SIZE_T < 8
|
|
#define RYU_32_BIT_PLATFORM
|
|
#endif
|
|
|
|
/* Returns e == 0 ? 1 : ceil(log_2(5^e)). */
|
|
static inline uint32
|
|
pow5bits(const int32 e)
|
|
{
|
|
/*
|
|
* This approximation works up to the point that the multiplication
|
|
* overflows at e = 3529.
|
|
*
|
|
* If the multiplication were done in 64 bits, it would fail at 5^4004
|
|
* which is just greater than 2^9297.
|
|
*/
|
|
Assert(e >= 0);
|
|
Assert(e <= 3528);
|
|
return ((((uint32) e) * 1217359) >> 19) + 1;
|
|
}
|
|
|
|
/* Returns floor(log_10(2^e)). */
|
|
static inline int32
|
|
log10Pow2(const int32 e)
|
|
{
|
|
/*
|
|
* The first value this approximation fails for is 2^1651 which is just
|
|
* greater than 10^297.
|
|
*/
|
|
Assert(e >= 0);
|
|
Assert(e <= 1650);
|
|
return (int32) ((((uint32) e) * 78913) >> 18);
|
|
}
|
|
|
|
/* Returns floor(log_10(5^e)). */
|
|
static inline int32
|
|
log10Pow5(const int32 e)
|
|
{
|
|
/*
|
|
* The first value this approximation fails for is 5^2621 which is just
|
|
* greater than 10^1832.
|
|
*/
|
|
Assert(e >= 0);
|
|
Assert(e <= 2620);
|
|
return (int32) ((((uint32) e) * 732923) >> 20);
|
|
}
|
|
|
|
static inline int
|
|
copy_special_str(char *const result, const bool sign, const bool exponent, const bool mantissa)
|
|
{
|
|
if (mantissa)
|
|
{
|
|
memcpy(result, "NaN", 3);
|
|
return 3;
|
|
}
|
|
if (sign)
|
|
{
|
|
result[0] = '-';
|
|
}
|
|
if (exponent)
|
|
{
|
|
memcpy(result + sign, "Infinity", 8);
|
|
return sign + 8;
|
|
}
|
|
result[sign] = '0';
|
|
return sign + 1;
|
|
}
|
|
|
|
static inline uint32
|
|
float_to_bits(const float f)
|
|
{
|
|
uint32 bits = 0;
|
|
|
|
memcpy(&bits, &f, sizeof(float));
|
|
return bits;
|
|
}
|
|
|
|
static inline uint64
|
|
double_to_bits(const double d)
|
|
{
|
|
uint64 bits = 0;
|
|
|
|
memcpy(&bits, &d, sizeof(double));
|
|
return bits;
|
|
}
|
|
|
|
#endif /* RYU_COMMON_H */
|