feefrac: add support for evaluating at given size

Author: sipa

src/test/feefrac_tests.cpp

@@ -17,6 +17,27 @@ BOOST_AUTO_TEST_CASE(feefrac_operators)
     FeeFrac empty{0, 0};
     FeeFrac zero_fee{0, 1}; // zero-fee allowed
 
+    BOOST_CHECK_EQUAL(zero_fee.Evaluate(0), 0);
+    BOOST_CHECK_EQUAL(zero_fee.Evaluate(1), 0);
+    BOOST_CHECK_EQUAL(zero_fee.Evaluate(1000000), 0);
+    BOOST_CHECK_EQUAL(zero_fee.Evaluate(0x7fffffff), 0);
+
+    BOOST_CHECK_EQUAL(p1.Evaluate(0), 0);
+    BOOST_CHECK_EQUAL(p1.Evaluate(1), 10);
+    BOOST_CHECK_EQUAL(p1.Evaluate(100000000), 1000000000);
+    BOOST_CHECK_EQUAL(p1.Evaluate(0x7fffffff), int64_t(0x7fffffff) * 10);
+
+    FeeFrac neg{-1001, 100};
+    BOOST_CHECK_EQUAL(neg.Evaluate(0), 0);
+    BOOST_CHECK_EQUAL(neg.Evaluate(1), -11);
+    BOOST_CHECK_EQUAL(neg.Evaluate(2), -21);
+    BOOST_CHECK_EQUAL(neg.Evaluate(3), -31);
+    BOOST_CHECK_EQUAL(neg.Evaluate(100), -1001);
+    BOOST_CHECK_EQUAL(neg.Evaluate(101), -1012);
+    BOOST_CHECK_EQUAL(neg.Evaluate(100000000), -1001000000);
+    BOOST_CHECK_EQUAL(neg.Evaluate(100000001), -1001000011);
+    BOOST_CHECK_EQUAL(neg.Evaluate(0x7fffffff), -21496311307);
+
     BOOST_CHECK(empty == FeeFrac{}); // same as no-args
 
     BOOST_CHECK(p1 == p1);
@@ -67,6 +88,11 @@ BOOST_AUTO_TEST_CASE(feefrac_operators)
     BOOST_CHECK(oversized_1 << oversized_2);
     BOOST_CHECK(oversized_1 != oversized_2);
 
+    BOOST_CHECK_EQUAL(oversized_1.Evaluate(0), 0);
+    BOOST_CHECK_EQUAL(oversized_1.Evaluate(1), 1152921);
+    BOOST_CHECK_EQUAL(oversized_1.Evaluate(2), 2305843);
+    BOOST_CHECK_EQUAL(oversized_1.Evaluate(1548031267), 1784758530396540);
+
     // Tests paths that use double arithmetic
     FeeFrac busted{(static_cast<int64_t>(INT32_MAX)) + 1, INT32_MAX};
     BOOST_CHECK(!(busted < busted));
@@ -77,6 +103,13 @@ BOOST_AUTO_TEST_CASE(feefrac_operators)
     BOOST_CHECK(max_fee <= max_fee);
     BOOST_CHECK(max_fee >= max_fee);
 
+    BOOST_CHECK_EQUAL(max_fee.Evaluate(0), 0);
+    BOOST_CHECK_EQUAL(max_fee.Evaluate(1), 977888);
+    BOOST_CHECK_EQUAL(max_fee.Evaluate(2), 1955777);
+    BOOST_CHECK_EQUAL(max_fee.Evaluate(3), 2933666);
+    BOOST_CHECK_EQUAL(max_fee.Evaluate(1256796054), 1229006664189047);
+    BOOST_CHECK_EQUAL(max_fee.Evaluate(INT32_MAX), 2100000000000000);
+
     FeeFrac max_fee2{1, 1};
     BOOST_CHECK(max_fee >= max_fee2);
 

src/test/fuzz/feefrac.cpp

@@ -170,4 +170,10 @@ FUZZ_TARGET(feefrac_mul_div)
     // Verify the behavior of FeeFrac::MulFallback + FeeFrac::DivFallback.
     auto res_fallback = FeeFrac::DivFallback(FeeFrac::MulFallback(mul64, mul32), div);
     assert(res == res_fallback);
+
+    // Verify the behavior of FeeFrac::Evaluate.
+    if (mul32 > 0) {
+        auto res_fee = FeeFrac{mul64, div}.Evaluate(mul32);
+        assert(res == res_fee);
+    }
 }

src/util/feefrac.h

@@ -182,6 +182,27 @@ struct FeeFrac
         std::swap(a.fee, b.fee);
         std::swap(a.size, b.size);
     }
+
+    /** Compute, at this object's feerate, how much fee does at_size correspond to.
+     *
+     * This effectively corresponds to evaluating (this->fee * at_size) / this->size, with the
+     * result rounded down (even for negative feerates).
+     *
+     * Requires this->size > 0, at_size >= 0, and that the correct result fits in a int64_t. This
+     * is guaranteed to be the case when 0 <= at_size <= this->size.
+     */
+    int64_t Evaluate(int32_t at_size) const noexcept
+    {
+        Assume(size > 0);
+        Assume(at_size >= 0);
+        if (fee >= 0 && fee < 0x200000000) [[likely]] {
+            // Common case where (this->fee * at_size) is guaranteed to fit in a uint64_t.
+            return (uint64_t(fee) * at_size) / uint32_t(size);
+        } else {
+            // Otherwise, use Mul and Div.
+            return Div(Mul(fee, at_size), size);
+        }
+    }
 };
 
 /** Compare the feerate diagrams implied by the provided sorted chunks data.