Merge pull request #929 from cppalliance/869

Fix `to_chars` for `decimal128` being disproportionally slower

Author: mborland

include/boost/decimal/charconv.hpp

@@ -324,7 +324,7 @@ BOOST_DECIMAL_CONSTEXPR auto to_chars_scientific_impl(char* first, char* last, c
     }
 
     // Offset the value of first by 1 so that we can copy the leading digit and insert a decimal point
-    auto r = to_chars_integer_impl<uint_type, uint_type>(first + 1, last, significand, 10);
+    auto r = to_chars_integer_impl<uint_type>(first + 1, last, significand);
 
     // Only real reason we will hit this is a buffer overflow
     if (BOOST_DECIMAL_UNLIKELY(!r))
@@ -398,7 +398,7 @@ BOOST_DECIMAL_CONSTEXPR auto to_chars_scientific_impl(char* first, char* last, c
         *first++ = '0';
     }
 
-    r = to_chars_integer_impl<int, unsigned>(first, last, abs_exp, 10);
+    r = to_chars_integer_impl<int>(first, last, abs_exp);
     if (BOOST_DECIMAL_UNLIKELY(!r))
     {
         return r; // LCOV_EXCL_LINE
@@ -544,7 +544,7 @@ BOOST_DECIMAL_CONSTEXPR auto to_chars_fixed_impl(char* first, char* last, const
                                           std::numeric_limits<std::uint64_t>::digits),
                                           int128::uint128_t, std::uint64_t>;
 
-    auto r = to_chars_integer_impl<uint_type, uint_type>(first, last, significand, 10);
+    auto r = to_chars_integer_impl<uint_type>(first, last, significand);
 
     if (BOOST_DECIMAL_UNLIKELY(!r))
     {
@@ -775,7 +775,7 @@ BOOST_DECIMAL_CONSTEXPR auto to_chars_hex_impl(char* first, char* last, const Ta
         *first++ = '0';
     }
 
-    return to_chars_integer_impl<std::uint32_t, std::uint32_t>(first, last, static_cast<std::uint32_t>(abs_exp), 10);
+    return to_chars_integer_impl<std::uint32_t>(first, last, static_cast<std::uint32_t>(abs_exp));
 }
 
 #ifdef _MSC_VER

include/boost/decimal/detail/memcpy.hpp

@@ -31,20 +31,61 @@ namespace boost {
 namespace decimal {
 namespace detail {
 
-#if !defined(BOOST_DECIMAL_NO_CONSTEVAL_DETECTION)
+namespace impl {
 
 #define BOOST_DECIMAL_CONSTEXPR constexpr
 
-BOOST_DECIMAL_CONSTEXPR char* memcpy(char* dest, const char* src, std::size_t count)
+constexpr char* memcpy_impl(char* dest, const char* src, std::size_t count)
 {
-    if (BOOST_DECIMAL_IS_CONSTANT_EVALUATED(count))
+    for (std::size_t i = 0; i < count; ++i)
+    {
+        dest[i] = src[i];
+    }
+
+    return dest;
+}
+
+constexpr char* memset_impl(char* dest, int ch, std::size_t count)
+{
+    for (std::size_t i = 0; i < count; ++i)
+    {
+        dest[i] = static_cast<char>(ch);
+    }
+
+    return dest;
+}
+
+constexpr char* memmove_impl(char* dest, const char* src, std::size_t count)
+{
+    if (dest < src || dest >= src + count)
     {
+        // Non-overlapping or safe to copy forward
         for (std::size_t i = 0; i < count; ++i)
         {
-            *(dest + i) = *(src + i);
+            dest[i] = src[i];
         }
+    }
+    else
+    {
+        // Overlapping, copy backward to avoid overwriting source
+        for (std::size_t i = count; i > 0; --i)
+        {
+            dest[i - 1] = src[i - 1];
+        }
+    }
 
-        return dest;
+    return dest;
+}
+
+}
+
+#if !defined(BOOST_DECIMAL_NO_CONSTEVAL_DETECTION)
+
+BOOST_DECIMAL_CONSTEXPR char* memcpy(char* dest, const char* src, std::size_t count)
+{
+    if (BOOST_DECIMAL_IS_CONSTANT_EVALUATED(count))
+    {
+        return static_cast<char*>(impl::memcpy_impl(dest, src, count));
     }
     else
     {
@@ -68,12 +109,7 @@ BOOST_DECIMAL_CONSTEXPR char* memset(char* dest, int ch, std::size_t count)
 {
     if (BOOST_DECIMAL_IS_CONSTANT_EVALUATED(count))
     {
-        for (std::size_t i = 0; i < count; ++i)
-        {
-            *(dest + i) = static_cast<char>(ch);
-        }
-
-        return dest;
+        return static_cast<char*>(impl::memset_impl(dest, ch, count));
     }
     else
     {
@@ -85,12 +121,7 @@ BOOST_DECIMAL_CONSTEXPR char* memmove(char* dest, const char* src, std::size_t c
 {
     if (BOOST_DECIMAL_IS_CONSTANT_EVALUATED(count))
     {
-        for (std::size_t i = 0; i < count; ++i)
-        {
-            *(dest + i) = *(src + i);
-        }
-
-        return dest;
+        return static_cast<char*>(impl::memmove_impl(dest, src, count));
     }
     else
     {
@@ -100,21 +131,19 @@ BOOST_DECIMAL_CONSTEXPR char* memmove(char* dest, const char* src, std::size_t c
 
 #else // No consteval detection
 
-#define BOOST_DECIMAL_CONSTEXPR inline
-
-BOOST_DECIMAL_CONSTEXPR void* memcpy(void* dest, const void* src, std::size_t count)
+BOOST_DECIMAL_CONSTEXPR char* memcpy(char* dest, const char* src, std::size_t count)
 {
-    return std::memcpy(dest, src, count);
+    return impl::memcpy_impl(dest, src, count);
 }
 
-BOOST_DECIMAL_CONSTEXPR void* memset(void* dest, int ch, std::size_t count)
+BOOST_DECIMAL_CONSTEXPR char* memset(char* dest, int ch, std::size_t count)
 {
-    return std::memset(dest, ch, count);
+    return impl::memset_impl(dest, ch, count);
 }
 
-BOOST_DECIMAL_CONSTEXPR void* memmove(void* dest, const void* src, std::size_t count)
+BOOST_DECIMAL_CONSTEXPR char* memmove(char* dest, const char* src, std::size_t count)
 {
-    return std::memmove(dest, src, count);
+    return impl::memmove_impl(dest, src, count);
 }
 
 #endif