Догнать и перегнать boost::lexical_cast

1/25
Догнать и перегнать boost::lexical_cast
Быстрое преобразование целого числа в строку
Орлов Роман
18 февраля 2017 г.
Орлов Роман Догнать и перегнать boost::lexical_cast

2/25
Готовые решения
Стандартная библиотека
• семейство printf (sprintf, snprintf)
• потоки ввода/вывода (std::basic_stringstream)
• std::to_string
• std::to_chars [C++17]
Boost
• Lexical Cast
• Format
• Iostreams
• Spirit Karma
А также fmtlib, FastFormat, Qt и другие…

3/25
Без динамического выделения памяти
• std::to_string
Boost
• Lexical Cast
• Format
• Iostreams
• Spirit Karma

3/25
Без динамического выделения памяти
• std::to_string
Boost
• Lexical Cast
• Format
• Iostreams ???
• Spirit Karma

4/25
Производительность boost::lexical_cast
Для всех xi = 100, i = 1, . . . , 10000
Clang 3.6.0 GCC 6.1.1
0
50
100
150
17
9
140
89
38
17
28
14
t,мс
lexical_cast std::stringstream+ctor std::stringstream printf

5/25
Под капотом boost::lexical_cast
Итерационное решение
inline CharT* main_convert_loop() BOOST_NOEXCEPT {
while (main_convert_iteration());
return m_finish;
}
inline bool main_convert_iteration() BOOST_NOEXCEPT {
--m_finish;
int_type const digit = static_cast<int_type>(m_value % 10U);
Traits::assign(*m_finish, Traits::to_char_type(m_zero + digit));
m_value /= 10;
return !!m_value; // suppressing warnings
}

5/25
return m_finish;
}
--m_finish;
m_value /= 10;
}
• Неизвестно количество итераций на момент компиляции.

5/25
return m_finish;
}
--m_finish;
m_value /= 10;
}
• Неизвестно количество итераций на момент компиляции.
• Вычисление веса каждого разряда, начиная с младшего.
Для числа 90000000000000000000 необходимо 20 раз вычислять веса
разрядов.

6/25
Проблема временного буфера
template <std::size_t N, class ArrayT>
bool shr_std_array(ArrayT& output) BOOST_NOEXCEPT {
using namespace std;
const std::size_t size = static_cast<std::size_t>(finish - start);
if (size > N - 1) { // ‘-1‘ because we need to store 0 at the end
return false;
}
memcpy(&output[0], start, size * sizeof(CharT));
output[size] = Traits::to_char_type(0);
return true;
}
• Использование временного буфера с последующим копированием.
• Сложность O(2N), где N – количество разрядов в числе.

7/25
Под капотом karma::generate
Рекурсивное решение без временного буфера
template <typename OutputIterator, typename T>
static bool call(OutputIterator& sink, T n, T& num, int exp) {
int ch = radix_type::call(remainder_type::call(n));
n = divide_type::call(n, num, ++exp);
BOOST_PP_REPEAT(BOOST_KARMA_NUMERICS_LOOP_UNROLL,
BOOST_KARMA_NUMERICS_INNER_LOOP_PREFIX, _);
if (!traits::test_zero(n))
call(sink, n, num, exp);
BOOST_KARMA_NUMERICS_INNER_LOOP_SUFFIX, _);
*sink = char(ch);
++sink;
return true;
}

7/25
Под капотом karma::generate
Рекурсивное решение без временного буфера
template <typename OutputIterator, typename T>
static bool call(OutputIterator& sink, T n, T& num, int exp) {
BOOST_KARMA_NUMERICS_INNER_LOOP_PREFIX, _);
if (!traits::test_zero(n))
call(sink, n, num, exp);
BOOST_KARMA_NUMERICS_INNER_LOOP_SUFFIX, _);
*sink = char(ch);
++sink;
return true;
}
#define BOOST_KARMA_NUMERICS_INNER_LOOP_PREFIX(z, x, data)
if (!traits::test_zero(n)) {
#define BOOST_KARMA_NUMERICS_INNER_LOOP_SUFFIX(z, x, data)
*sink = char(ch);
++sink;
}

8/25
Требования к алгоритму
• Без динамического выделения памяти
• Известно число итераций на момент компиляции
• Получение результата без промежуточной буферизации
• Поддержка итераторов

9/25
[int2str] На верхнем уровне
template<typename T, typename Iter>
inline Iter convert(T x, Iter iter)
{
static_assert(std::is_integral<T>::value,
”T must be integral type”);
return impl::converter<typename std::decay<T>::type>::run(x, iter);
}
T – целочисленный тип,
Iter – forward-итератор, для которого применимо *iter = char()
inline Iter convert_c_str(T x, Iter iter)
{
iter = convert(x, iter);
*iter++ = 0;
return iter;
}

10/25
[int2str] Основной алгоритм
Поиск первого делителя
template<number_t N>
struct detail
{
template<typename Iter>
inline static Iter convert(number_t x, Iter iter)
{
if (N > x)
return detail<N / 10u>::convert(x, iter);
return detail<N>::convert_step(x, iter);
}
inline static Iter convert_step(number_t x, Iter iter);
};
N – делитель для получения веса старшего разряда,
N = 10000000000000000000, 1000000000000000000, . . . , 100, 10, 1

11/25
Генерация строки
template<number_t N>
Iter detail<N>::convert_step(number_t x, Iter iter)
{
if (N > x)
{
*iter++ = ’0’;
return detail<N / 10u>::convert_step(x, iter);
}
auto const w = x / N; // <-- DIVISION BY CONSTANT
*iter++ = static_cast<char>(’0’ + w);
return detail<N / 10u>::convert_step(x - w * N, iter);
}
• Веса разрядов вычисляются от старших к младшим.
• Чем больше в числе нулевых разрядов, тем быстрее работает
алгоритм.

12/25
Конец генерации строки
template<>
struct detail<1u>
{
inline static Iter convert(number_t x, Iter iter)
{
return convert_step(x, iter);
}
inline static Iter convert_step(number_t x, Iter iter)
{
*iter++ = static_cast<char>(’0’ + x);
return iter;
}
};

13/25
[int2str] Плохое решение
Выбор делителя N
Iter convert(T x, Iter iter)
{
return detail< ? >()>::convert(x, iter); // What N should be here?
}

13/25
{
}
Пусть N=10000000000000000000, делителю наибольшего числа.

13/25
{
}
Пусть N=10000000000000000000, делителю наибольшего числа.
При T=unsigned char и x=42 получим
detail<10000000000000000000>::convert(x, iter)
Для поиска первого делителя числа x, т.е.
будет выполнено 18 сравнений N>x.

14/25
[int2str] Максимальный делитель по типу
Предопределенные константы
template<size_t N>
constexpr number_t get_max_divider();
template<>
constexpr number_t get_max_divider<1u>()
{
return 100u;
}
template<>
{
return 10000u;
}
…

14/25
Предопределенные константы
template<size_t N>
constexpr number_t get_max_divider();
template<>
{
return 100u;
}
template<>
{
return 10000u;
}
…
template<typename T>
constexpr number_t get_max_divider()
{
return get_max_divider<sizeof(T)>();
}

15/25
Вычисление на этапе компиляции
constexpr number_t get_max_divider(number_t n = 1)
{
return (std::numeric_limits<T>::max() / n <= 9 ? n
: get_max_divider<T>(n * 10));
}

15/25
{
}
{
return detail<get_max_divider<T>()>::convert(x, iter);
}

15/25
{
}
{
return detail<get_max_divider<T>()>::convert(x, iter);
}
При T=uint64_t и x=42 получим
Для поиска первого делителя x снова выполним 18 сравнений N>x.

16/25
[int2str] Итерация по типам
Введем метафункцию next_type(T) = U, T ∈ I, U ∈ I,
I – множество беззнаковых целых типов, sizeof(T) ≤ sizeof(U).
Если T ∼ U, то T – тип максимального размера.
struct next_type {
typedef unsigned long long type;
};

16/25
struct next_type {
};
template<>
struct next_type<unsigned char> { // sizeof(char) < sizeof(short)
typedef unsigned short type;
};
template<>
struct next_type<unsigned short> { // sizeof(short) < sizeof(int)
typedef unsigned int type;
};

16/25
struct next_type {
};
template<>
struct next_type<unsigned char> { // sizeof(char) < sizeof(short)
typedef unsigned short type;
};
template<>
struct next_type<unsigned short> { // sizeof(short) < sizeof(int)
typedef unsigned int type;
};
Для остальных типов специализации не нужны
next_type<unsigned int> → unsigned long long
next_type<unsigned long long> → unsigned long long

17/25
[int2str] Выбор наиболее близкого делителя
template<typename FromT=unsigned char,
typename T,
typename Iter>
inline Iter convert_from(T x, Iter iter)
{
if (x <= std::numeric_limits<FromT>::max())
return detail<get_max_divider<FromT>()>::convert(x, iter);
return convert_from<typename next_type<FromT>::type>(x, iter);
}
Если T=uint64_t и x=42, то при вызове
convert_from<unsigned char>(x, iter)
будет использована специализация
вместо первоначальной

18/25
[int2str] Реализация конвертера
template<typename T, typename Enable=void>
struct converter
{
inline static Iter run(T x, Iter iter) {
return convert_from(x, iter);
}
};

18/25
[int2str] Реализация конвертера
template<typename T, typename Enable=void>
struct converter
{
return convert_from(x, iter);
}
};
struct converter< T,
typename std::enable_if<std::is_signed<T>::value>::type>
{
using U = typename std::make_unsigned<T>::type;
if (x < 0) {
*iter++ = ’-’;
return convert_from(static_cast<U>(-x), iter);
}
return convert_from(static_cast<U>(x), iter);
}
};

19/25
Результаты тестирования
Компиляторы и библиотеки
GCC 6
• GCC 6.2.1 20160916
Clang
• Clang 3.8.0 (tags/RELEASE_380/final)
MS Visual Studio 2015
• CL 19.00.24215.1
Boost
• Boost 1.62.0, September 28th, 2016 15:17 GMT

20/25
Синтетический случай
Для всех xi = i, i = INT_MIN, . . . , INT_MAX
clang -O3 gcc -O3 clang -O2 gcc -O2 msvc /O2 /GL
0
200
400
600
2 2 2 2 2
100 101 99 100 112
264
378
260
379
635
255
435
366
436
286
t,с
null int2str::convert boost::lexical_cast karma::generate

21/25
Общий случай
Для всех xi = random(INT_MIN, INT_MAX), i = 1, . . . , 10000000
clang -O3 gcc -O3 clang -O2 gcc -O2 msvc /O2 /GL
0
2
4
6
8
10
1.53 1.59 1.55 1.59
9.13
2.1 2.18 2.09 2.36
9.65
2.28 2.54 2.29 2.53
10.69
2.21
2.75 2.48 2.73
9.86
t,с
null int2str::convert boost::lexical_cast karma::generate

22/25
Особенности компиляции
int2str::convert VS boost::lexical_cast ON clang -O3
int2str::convert(9001,…)
mov ax,di
movzx ecx,ax
cmp edi,0xff
ja 0x400a38
0x400a38 cmp ecx,0x270f
ja XXXX
cmp ecx,0x3e7
ja 0x400af2
0x400af2 jmp 0x400b00
0x400b00 cmp rdi,0x3e7
ja 0x400b1b
0x400b1b mov rax,rdi
shr rax,0x3
movabs rcx,0x20c49ba5e353f7cf
mul rcx
shr rdx,0x4
lea eax,[rdx+0x30]
mov BYTE PTR [rsi],al
imul rcx,rdx,0xfffffffffffffc18
add rcx,rdi
cmp rcx,0x63
ja XXXX
mov BYTE PTR [rsi+0x1],0x30
cmp rcx,0x9
ja XXXX
add rcx,0x30
mov BYTE PTR [rsi+0x3],cl
jmp 0x400c51
0x400c51 add rsi,0x4
mov rax,rsi

22/25
mov ax,di
movzx ecx,ax
cmp edi,0xff
ja 0x400a38
ja XXXX
cmp ecx,0x3e7
ja 0x400af2
0x400af2 jmp 0x400b00
ja 0x400b1b
shr rax,0x3
mul rcx
shr rdx,0x4
lea eax,[rdx+0x30]
add rcx,rdi
cmp rcx,0x63
ja XXXX
cmp rcx,0x9
ja XXXX
add rcx,0x30
jmp 0x400c51
mov rax,rsi
boost::lexical_cast<…>(9001)
0x401390 mov rdx,QWORD PTR [rbx+0x8]
lea rsi,[rdx-0x1]
mov QWORD PTR [rbx+0x8],rsi
mov esi,ecx
imul rsi,rax
shr rsi,0x23
add esi,esi
lea esi,[rsi+rsi*4]
sub ecx,esi
add ecx,DWORD PTR [rbx+0x14]
mov BYTE PTR [rdx-0x1],cl
movsxd rdx,DWORD PTR [rbx]
imul rcx,rdx,0x66666667
mov rsi,rcx
shr rsi,0x3f
sar rcx,0x22
add ecx,esi
mov DWORD PTR [rbx],ecx
lea edx,[rdx+0x9]
cmp edx,0x12
ja 0x401390

22/25
mov ax,di
movzx ecx,ax
cmp edi,0xff
ja 0x400a38
ja XXXX
cmp ecx,0x3e7
ja 0x400af2
0x400af2 jmp 0x400b00
ja 0x400b1b
shr rax,0x3
mul rcx
shr rdx,0x4
lea eax,[rdx+0x30]
add rcx,rdi
cmp rcx,0x63
ja XXXX
cmp rcx,0x9
ja XXXX
add rcx,0x30
jmp 0x400c51
mov rax,rsi
boost::lexical_cast<…>(9001)
0x401390 mov rdx,QWORD PTR [rbx+0x8]
lea rsi,[rdx-0x1]
mov QWORD PTR [rbx+0x8],rsi
mov esi,ecx
imul rsi,rax
shr rsi,0x23
add esi,esi
lea esi,[rsi+rsi*4]
sub ecx,esi
add ecx,DWORD PTR [rbx+0x14]
mov BYTE PTR [rdx-0x1],cl
movsxd rdx,DWORD PTR [rbx]
imul rcx,rdx,0x66666667
mov rsi,rcx
shr rsi,0x3f
sar rcx,0x22
add ecx,esi
mov DWORD PTR [rbx],ecx
lea edx,[rdx+0x9]
cmp edx,0x12
ja 0x401390
x4

23/25
clang -O3 VS gcc -O3
mov ax,di
movzx ecx,ax
cmp edi,0xff
ja 0x400a38
ja XXXX
cmp ecx,0x3e7
ja 0x400af2
0x400af2 jmp 0x400b00
ja 0x400b1b
shr rax,0x3
mul rcx
shr rdx,0x4
lea eax,[rdx+0x30]
add rcx,rdi
cmp rcx,0x63
ja XXXX
cmp rcx,0x9
ja XXXX
add rcx,0x30
jmp 0x400c51
mov rax,rsi
cmp cx,0xff
movsx rax,cx
jle XXXX
cmp cx,0x270f
jle 0x400964
0x400964 cmp cx,0x3e7
jle XXXX
xor edx,edx
mov ecx,0x3e8
div rcx
add eax,0x30
cmp rdx,0x63
mov BYTE PTR [rsp],al
ja XXXX
cmp rdx,0x9
mov BYTE PTR [rsp+0x1],0x30
ja XXXX
lea eax,[rdx+0x30]
mov BYTE PTR [rsp+0x2],0x30
mov rsi,rsp
mov BYTE PTR [rsp+0x3],al
lea rax,[rsp+0x4]
jmp XXXX

24/25
Итоги
#include <int2str/int2str.hpp>
#include <string>
#include <iostream>
int main()
{
std::string msg = ”C++ Russia ”;
int2str::convert(2017, std::back_inserter(msg));
std::cout << msg << std::endl;
return 0;
}
Нет динамического выделения памяти.
На момент компиляции известно число итераций.
Результат формируется без промежуточной буферизации.
Работа через итераторы.
Быстрее boost::lexical_cast.

25/25
Спасибо за внимание!
https://github.com/compmaniak/int2str

Догнать и перегнать boost::lexical_cast

More Related Content

What's hot

Similar to Догнать и перегнать boost::lexical_cast

Догнать и перегнать boost::lexical_cast