Improve decimal128 multiplication

Author: mborland

include/boost/decimal/decimal128.hpp

@@ -1682,15 +1682,9 @@ constexpr auto operator*(decimal128 lhs, decimal128 rhs) noexcept -> decimal128
 
     auto lhs_sig {lhs.full_significand()};
     auto lhs_exp {lhs.biased_exponent()};
-    const auto lhs_zeros {detail::remove_trailing_zeros(lhs_sig)};
-    lhs_sig = lhs_zeros.trimmed_number;
-    lhs_exp += static_cast<std::int32_t>(lhs_zeros.number_of_removed_zeros);
 
     auto rhs_sig {rhs.full_significand()};
     auto rhs_exp {rhs.biased_exponent()};
-    const auto rhs_zeros {detail::remove_trailing_zeros(rhs_sig)};
-    rhs_sig = rhs_zeros.trimmed_number;
-    rhs_exp += static_cast<std::int32_t>(rhs_zeros.number_of_removed_zeros);
 
     return detail::d128_mul_impl<decimal128>(
             lhs_sig, lhs_exp, lhs.isneg(),

include/boost/decimal/detail/mul_impl.hpp

@@ -171,22 +171,35 @@ constexpr auto d128_mul_impl(T1 lhs_sig, std::int32_t lhs_exp, bool lhs_sign,
 {
     bool sign {lhs_sign != rhs_sign};
 
-    // Once we have the normalized significands and exponents all we have to do is
-    // multiply the significands and add the exponents
-    auto res_sig {detail::umul256(lhs_sig, rhs_sig)};
-    auto res_exp {lhs_exp + rhs_exp};
-
-    const auto sig_dig {detail::num_digits(res_sig)};
+    const auto lhs_dig {detail::num_digits(lhs_sig)};
+    const auto rhs_dig {detail::num_digits(rhs_sig)};
 
-    if (sig_dig > std::numeric_limits<detail::uint128>::digits10)
+    // If we can avoid it don't do 256 bit multiplication because it is slow
+    if (lhs_dig * rhs_dig <= std::numeric_limits<uint128>::digits10)
     {
-        const auto digit_delta {sig_dig - std::numeric_limits<detail::uint128>::digits10};
-        res_sig /= detail::uint256_t(pow10(detail::uint128(digit_delta)));
-        res_exp += digit_delta;
+        auto res_sig {lhs_sig * rhs_sig};
+        auto res_exp {lhs_exp + rhs_exp};
+        return {res_sig, res_exp, sign};
+    }
+    else
+    {
+        // Once we have the normalized significands and exponents all we have to do is
+        // multiply the significands and add the exponents
+        auto res_sig {detail::umul256(lhs_sig, rhs_sig)};
+        auto res_exp {lhs_exp + rhs_exp};
+
+        const auto sig_dig {detail::num_digits(res_sig)};
+
+        if (sig_dig > std::numeric_limits<detail::uint128>::digits10)
+        {
+            const auto digit_delta {sig_dig - std::numeric_limits<detail::uint128>::digits10};
+            res_sig /= detail::uint256_t(pow10(detail::uint128(digit_delta)));
+            res_exp += digit_delta;
+        }
+
+        BOOST_DECIMAL_ASSERT(res_sig.high == uint128(0, 0));
+        return {res_sig.low, res_exp, sign};
     }
-
-    BOOST_DECIMAL_ASSERT(res_sig.high == uint128(0,0));
-    return {res_sig.low, res_exp, sign};
 }
 
 template <typename ReturnType, BOOST_DECIMAL_INTEGRAL T1, BOOST_DECIMAL_INTEGRAL U1,