highperfocused/bitcoin
1
0
Fork 0
mirror of https://github.com/bitcoin/bitcoin.git synced 2026-01-19 23:03:45 +01:00
Code Issues Packages Projects Releases Wiki Activity

feefrac: support both rounding up and down for Evaluate

Browse Source 
Co-Authored-By: l0rinc <pap.lorinc@gmail.com>
This commit is contained in:
Pieter Wuille
2024-07-30 11:48:32 -04:00
parent ecf956ec9d
commit 0c6bcfd8f7
3 changed files with 124 additions and 65 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
src/test/fuzz/feefrac.cpp
View File

@@ -110,20 +110,24 @@ FUZZ_TARGET(feefrac_div_fallback)
{
// Verify the behavior of FeeFrac::DivFallback over all possible inputs.
// Construct a 96-bit signed value num, and positive 31-bit value den.
// Construct a 96-bit signed value num, a positive 31-bit value den, and rounding mode.
FuzzedDataProvider provider(buffer.data(), buffer.size());
auto num_high = provider.ConsumeIntegral<int64_t>();
auto num_low = provider.ConsumeIntegral<uint32_t>();
std::pair<int64_t, uint32_t> num{num_high, num_low};
auto den = provider.ConsumeIntegralInRange<int32_t>(1, std::numeric_limits<int32_t>::max());
auto round_down = provider.ConsumeBool();
// Predict the sign of the actual result.
bool is_negative = num_high < 0;
// Evaluate absolute value using arith_uint256. If the actual result is negative, the absolute
// value of the quotient is the rounded-up quotient of the absolute values.
// Evaluate absolute value using arith_uint256. If the actual result is negative and we are
// rounding down, or positive and we are rounding up, the absolute value of the quotient is
// the rounded-up quotient of the absolute values.
auto num_abs = Abs256(num);
auto den_abs = Abs256(den);
auto quot_abs = is_negative ? (num_abs + den_abs - 1) / den_abs : num_abs / den_abs;
auto quot_abs = (is_negative == round_down) ?
(num_abs + den_abs - 1) / den_abs :
num_abs / den_abs;
// If the result is not representable by an int64_t, bail out.
if ((is_negative && quot_abs > MAX_ABS_INT64) || (!is_negative && quot_abs >= MAX_ABS_INT64)) {
@@ -131,12 +135,13 @@ FUZZ_TARGET(feefrac_div_fallback)
}
// Verify the behavior of FeeFrac::DivFallback.
auto res = FeeFrac::DivFallback(num, den);
assert((res < 0) == is_negative);
auto res = FeeFrac::DivFallback(num, den, round_down);
assert(res == 0 || (res < 0) == is_negative);
assert(Abs256(res) == quot_abs);
// Compare approximately with floating-point.
long double expect = std::floor(num_high * 4294967296.0L + num_low) / den;
long double expect = round_down ? std::floor(num_high * 4294967296.0L + num_low) / den
: std::ceil(num_high * 4294967296.0L + num_low) / den;
// Expect to be accurate within 50 bits of precision, +- 1 sat.
if (expect == 0.0L) {
assert(res >= -1 && res <= 1);
@@ -156,40 +161,45 @@ FUZZ_TARGET(feefrac_mul_div)
// - The combination of FeeFrac::MulFallback + FeeFrac::DivFallback.
// - FeeFrac::Evaluate.
// Construct a 32-bit signed multiplicand, a 64-bit signed multiplicand, and a positive 31-bit
// divisor.
// Construct a 32-bit signed multiplicand, a 64-bit signed multiplicand, a positive 31-bit
// divisor, and a rounding mode.
FuzzedDataProvider provider(buffer.data(), buffer.size());
auto mul32 = provider.ConsumeIntegral<int32_t>();
auto mul64 = provider.ConsumeIntegral<int64_t>();
auto div = provider.ConsumeIntegralInRange<int32_t>(1, std::numeric_limits<int32_t>::max());
auto round_down = provider.ConsumeBool();
// Predict the sign of the overall result.
bool is_negative = ((mul32 < 0) && (mul64 > 0)) || ((mul32 > 0) && (mul64 < 0));
// Evaluate absolute value using arith_uint256. If the actual result is negative, the absolute
// value of the quotient is the rounded-up quotient of the absolute values.
// Evaluate absolute value using arith_uint256. If the actual result is negative and we are
// rounding down or positive and we rounding up, the absolute value of the quotient is the
// rounded-up quotient of the absolute values.
auto prod_abs = Abs256(mul32) * Abs256(mul64);
auto div_abs = Abs256(div);
auto quot_abs = is_negative ? (prod_abs + div_abs - 1) / div_abs : prod_abs / div_abs;
auto quot_abs = (is_negative == round_down) ?
(prod_abs + div_abs - 1) / div_abs :
prod_abs / div_abs;
// If the result is not representable by an int64_t, bail out.
if ((is_negative && quot_abs > MAX_ABS_INT64) || (!is_negative && quot_abs >= MAX_ABS_INT64)) {
// If 0 <= mul32 <= div, then the result is guaranteed to be representable. In the context
// of the Evaluate call below, this corresponds to 0 <= at_size <= feefrac.size.
// of the Evaluate{Down,Up} calls below, this corresponds to 0 <= at_size <= feefrac.size.
assert(mul32 < 0 || mul32 > div);
return;
}
// Verify the behavior of FeeFrac::Mul + FeeFrac::Div.
auto res = FeeFrac::Div(FeeFrac::Mul(mul64, mul32), div);
assert((res < 0) == is_negative);
auto res = FeeFrac::Div(FeeFrac::Mul(mul64, mul32), div, round_down);
assert(res == 0 || (res < 0) == is_negative);
assert(Abs256(res) == quot_abs);
// Verify the behavior of FeeFrac::MulFallback + FeeFrac::DivFallback.
auto res_fallback = FeeFrac::DivFallback(FeeFrac::MulFallback(mul64, mul32), div);
auto res_fallback = FeeFrac::DivFallback(FeeFrac::MulFallback(mul64, mul32), div, round_down);
assert(res == res_fallback);
// Compare approximately with floating-point.
long double expect = std::floor(static_cast<long double>(mul32) * mul64 / div);
long double expect = round_down ? std::floor(static_cast<long double>(mul32) * mul64 / div)
: std::ceil(static_cast<long double>(mul32) * mul64 / div);
// Expect to be accurate within 50 bits of precision, +- 1 sat.
if (expect == 0.0L) {
assert(res >= -1 && res <= 1);
@@ -201,9 +211,11 @@ FUZZ_TARGET(feefrac_mul_div)
assert(res <= expect * 0.999999999999999L + 1.0L);
}
// Verify the behavior of FeeFrac::Evaluate.
// Verify the behavior of FeeFrac::Evaluate{Down,Up}.
if (mul32 >= 0) {
auto res_fee = FeeFrac{mul64, div}.EvaluateFee(mul32);
auto res_fee = round_down ?
FeeFrac{mul64, div}.EvaluateFeeDown(mul32) :
FeeFrac{mul64, div}.EvaluateFeeUp(mul32);
assert(res == res_fee);
}
}