perf: optimize division to uint32 to make re-target-pow calculation much faster

Author: knst

src/arith_uint256.cpp

@@ -5,6 +5,7 @@
 
 #include <arith_uint256.h>
 
+#include <limits>
 #include <uint256.h>
 #include <crypto/common.h>
 
@@ -72,6 +73,23 @@ base_uint<BITS>& base_uint<BITS>::operator*=(const base_uint& b)
     return *this;
 }
 
+template <unsigned int BITS>
+base_uint<BITS>& base_uint<BITS>::operator/=(uint64_t b32)
+{
+    if (b32 == 0)
+        throw uint_error("Division by zero");
+    if (b32 > std::numeric_limits<uint32_t>::max()) {
+        return *this /= base_uint(b32);
+    }
+    uint64_t rem = 0;
+    for (int i = WIDTH - 1; i >= 0; --i) {
+        uint64_t cur = (rem << 32) | pn[i];
+        pn[i] = static_cast<uint32_t>(cur / b32);
+        rem = cur % b32;
+    }
+    return *this;
+}
+
 template <unsigned int BITS>
 base_uint<BITS>& base_uint<BITS>::operator/=(const base_uint& b)
 {

src/arith_uint256.h

@@ -158,6 +158,7 @@ class base_uint
 
     base_uint& operator*=(uint32_t b32);
     base_uint& operator*=(const base_uint& b);
+    base_uint& operator/=(uint64_t b32);
     base_uint& operator/=(const base_uint& b);
 
     base_uint& operator++()
@@ -207,6 +208,7 @@ class base_uint
     friend inline base_uint operator>>(const base_uint& a, int shift) { return base_uint(a) >>= shift; }
     friend inline base_uint operator<<(const base_uint& a, int shift) { return base_uint(a) <<= shift; }
     friend inline base_uint operator*(const base_uint& a, uint32_t b) { return base_uint(a) *= b; }
+    friend inline base_uint operator/(const base_uint& a, uint64_t b) { return base_uint(a) /= b; }
     friend inline bool operator==(const base_uint& a, const base_uint& b) { return memcmp(a.pn, b.pn, sizeof(a.pn)) == 0; }
     friend inline bool operator!=(const base_uint& a, const base_uint& b) { return memcmp(a.pn, b.pn, sizeof(a.pn)) != 0; }
     friend inline bool operator>(const base_uint& a, const base_uint& b) { return a.CompareTo(b) > 0; }