производительность — C ++: самый быстрый способ преобразования байта в беззнаковое целое

Правильный ответ почти всегда:

Напишите правильный код, включите оптимизацию, доверьтесь компилятору.

дано:

void count_values(std::array<uint32_t, 256^3>& results,
const unsigned char* from,
const unsigned char* to)
{
for(; from != to; from  = std::next(from, 3)) {
++results[(*from << 16) | (*std::next(from, 1) << 8) | *(std::next(from,2))];
}
}

составлено с -O3

Урожайность (пояснительные комментарии включены):

__Z12count_valuesRNSt3__15arrayIjLm259EEEPKhS4_: ## @_Z12count_valuesRNSt3__15arrayIjLm259EEEPKhS4_
.cfi_startproc
## BB#0:
pushq   %rbp
Ltmp0:
.cfi_def_cfa_offset 16
Ltmp1:
.cfi_offset %rbp, -16
movq    %rsp, %rbp
Ltmp2:
.cfi_def_cfa_register %rbp
jmp LBB0_2
.align  4, 0x90
LBB0_1:                                 ## %.lr.ph
##   in Loop: Header=BB0_2 Depth=1
# dereference from and extend the 8-bit value to 32 bits
movzbl  (%rsi), %eax
shlq    $16, %rax            # shift left 16
movzbl  1(%rsi), %ecx        # dereference *(from+1) and extend to 32bits by padding with zeros
shlq    $8, %rcx             # shift left 8
orq %rax, %rcx               # or into above result
movzbl  2(%rsi), %eax        # dreference *(from+2) and extend to 32bits
orq %rcx, %rax               # or into above result
incl    (%rdi,%rax,4)        # increment the correct counter
addq    $3, %rsi             # from += 3
LBB0_2:                                 ## %.lr.ph
## =>This Inner Loop Header: Depth=1
cmpq    %rdx, %rsi           # while from != to
jne LBB0_1
## BB#3:                                ## %._crit_edge
popq    %rbp
retq
.cfi_endproc

Обратите внимание, что нет необходимости отклоняться от стандартных конструкций или стандартных вызовов. Компилятор выдает идеальный код.

Чтобы дополнительно доказать это, давайте сходим с ума и напишем собственный итератор, который позволит нам сократить функцию до этой:

void count_values(std::array<uint32_t, 256^3>& results,
byte_triple_iterator from,
byte_triple_iterator to)
{
assert(iterators_correct(from, to));
while(from != to) {
++results[*from++];
}
}

А вот (базовая) реализация такого итератора:

struct byte_triple_iterator
{
constexpr byte_triple_iterator(const std::uint8_t* p)
: _ptr(p)
{}

std::uint32_t operator*() const noexcept {
return (*_ptr << 16) | (*std::next(_ptr, 1) << 8) | *(std::next(_ptr,2));
}

byte_triple_iterator& operator++() noexcept {
_ptr = std::next(_ptr, 3);
return *this;
}

byte_triple_iterator operator++(int) noexcept {
auto copy = *this;
_ptr = std::next(_ptr, 3);
return copy;
}

constexpr const std::uint8_t* byte_ptr() const {
return _ptr;
}

private:

friend bool operator<(const byte_triple_iterator& from, const byte_triple_iterator& to)
{
return from._ptr < to._ptr;
}

friend bool operator==(const byte_triple_iterator& from, const byte_triple_iterator& to)
{
return from._ptr == to._ptr;
}

friend bool operator!=(const byte_triple_iterator& from, const byte_triple_iterator& to)
{
return not(from == to);
}

friend std::ptrdiff_t byte_difference(const byte_triple_iterator& from, const byte_triple_iterator& to)
{
return to._ptr - from._ptr;
}

const std::uint8_t* _ptr;
};

bool iterators_correct(const byte_triple_iterator& from,
const byte_triple_iterator& to)
{
if (not(from < to))
return false;
auto dist = to.byte_ptr() - from.byte_ptr();
return dist % 3 == 0;
}

Теперь, что у нас есть?

• утверждение, чтобы проверить, что наш источник действительно имеет правильную длину (в отладочной сборке)
• выходная структура, которая гарантированно будет иметь правильный размер

Но что это сделало с нашим объектным кодом? (скомпилировать с -O3 -DNDEBUG)

    .globl  __Z12count_valuesRNSt3__15arrayIjLm259EEE20byte_triple_iteratorS3_
.align  4, 0x90
__Z12count_valuesRNSt3__15arrayIjLm259EEE20byte_triple_iteratorS3_: ## @_Z12count_valuesRNSt3__15arrayIjLm259EEE20byte_triple_iteratorS3_
.cfi_startproc
## BB#0:
pushq   %rbp
Ltmp3:
.cfi_def_cfa_offset 16
Ltmp4:
.cfi_offset %rbp, -16
movq    %rsp, %rbp
Ltmp5:
.cfi_def_cfa_register %rbp
jmp LBB1_2
.align  4, 0x90
LBB1_1:                                 ## %.lr.ph
##   in Loop: Header=BB1_2 Depth=1
movzbl  (%rsi), %eax
shlq    $16, %rax
movzbl  1(%rsi), %ecx
shlq    $8, %rcx
orq %rax, %rcx
movzbl  2(%rsi), %eax
orq %rcx, %rax
incl    (%rdi,%rax,4)
addq    $3, %rsi
LBB1_2:                                 ## %.lr.ph
## =>This Inner Loop Header: Depth=1
cmpq    %rdx, %rsi
jne LBB1_1
## BB#3:                                ## %._crit_edge
popq    %rbp
retq
.cfi_endproc

Ответ: ничего такого — это так же эффективно.

Урок? нет действительно! Доверяй своему компилятору !!!