У нас тут идет второй день тренинг по С++ и unit-тестированию. Ведет Kevlin Henney. Отличный дядка.

Все как обычно – стараемся приучать к культуре разработки через тесты, ну и попутно склонить патриотов С к С++, убедив их, что на С++ можно таки писать также эффективно, как и на С. Да еще и в разы быстрее.

Зашла тема про std::fill(). Я вставил словечко, что мол fill() работает также быстро как и memset(), так как он используется в fill() для простых типов.

Написали программу, в которой есть интересный момент.

#include <cstdlib>
#include <algorithm>

int main(int argc, char* argv[]) {
  int mode = argc > 1 ? std::atoi(argv[1]) : 1;
  int n = 1024 * 1024 * 1024 * 1;
  char* buf = new char[n];
  if (mode == 1)
    std::memset(buf, 0, n * sizeof(*buf));
  else if (mode == 2)
    bzero(buf, n * sizeof(*buf));
  else if (mode == 3)
    std::fill(buf, buf + n, 0);
  else if (mode == 4)
    std::fill(buf, buf + n, '\0');
  return buf[0];
}

Обратите внимание на ветки 3 и 4. Они почти одно и то же, но не совсем.

В целом была мысль получить вот эту специализацию fill():

// Specialization: for one-byte types we can use memset.
inline void
fill(unsigned char* __first, unsigned char* __last, const unsigned char& __c)
{
  __glibcxx_requires_valid_range(__first, __last);
  const unsigned char __tmp = __c;
  std::memset(__first, __tmp, __last - __first);
}

Итак, Makefile:

all: build run

.SILENT:

target = memset_bzero_fill

build:
        g++ -O3 -o $(target) $(target).cpp

run: run-memset run-bzero run-fill-1 run-fill-2

go:
        (time -p ./$(target) $(mode)) 2>&1 | head -1 | cut -d' ' -f 2

run-memset:
        echo $@ `$(MAKE) go mode=1`

run-bzero:
        echo $@ `$(MAKE) go mode=2`

run-fill-1:
        echo $@ `$(MAKE) go mode=3`

run-fill-2:
        echo $@ `$(MAKE) go mode=4`

Компилятор “gcc version 4.2.1 (Apple Inc. build 5666) (dot 3)”.

Запускаем:

run-memset 1.47
run-bzero 1.45
run-fill-1 1.69
run-fill-2 1.42

Видно, как ветка 3 (run-fill-1) значительно тормозит, по сравнению с 4, хотя разница всего в типе последнего параметра - 0 и ‘\0’.

Смотрим ассемблер:

(gdb) disass main
Dump of assembler code for function main:
0x0000000100000e70 <main+0>:    push   %rbp
0x0000000100000e71 <main+1>:    mov    %rsp,%rbp
0x0000000100000e74 <main+4>:    push   %r12
0x0000000100000e76 <main+6>:    push   %rbx
0x0000000100000e77 <main+7>:    dec    %edi
0x0000000100000e79 <main+9>:    jle    0x100000ec3 <main+83>
0x0000000100000e7b <main+11>:   mov    0x8(%rsi),%rdi
0x0000000100000e7f <main+15>:   callq  0x100000efe <dyld_stub_atoi>
0x0000000100000e84 <main+20>:   mov    %eax,%r12d
0x0000000100000e87 <main+23>:   mov    $0x40000000,%edi
0x0000000100000e8c <main+28>:   callq  0x100000ef8 <dyld_stub__Znam>
0x0000000100000e91 <main+33>:   mov    %rax,%rbx
0x0000000100000e94 <main+36>:   cmp    $0x1,%r12d
0x0000000100000e98 <main+40>:   je     0x100000eac <main+60>   ; mode == 1
0x0000000100000e9a <main+42>:   cmp    $0x2,%r12d
0x0000000100000e9e <main+46>:   je     0x100000eac <main+60>   ; mode == 2
0x0000000100000ea0 <main+48>:   cmp    $0x3,%r12d
0x0000000100000ea4 <main+52>:   je     0x100000ed2 <main+98>   ; mode == 3
0x0000000100000ea6 <main+54>:   cmp    $0x4,%r12d
0x0000000100000eaa <main+58>:   jne    0x100000ebb <main+75>   ; mode != 4 -> выход

; Реалиазация через memset().

0x0000000100000eac <main+60>:   mov    $0x40000000,%edx        ; mode = 1, 2 или 4
0x0000000100000eb1 <main+65>:   xor    %esi,%esi
0x0000000100000eb3 <main+67>:   mov    %rbx,%rdi
0x0000000100000eb6 <main+70>:   callq  0x100000f0a <dyld_stub_memset>

0x0000000100000ebb <main+75>:   movsbl (%rbx),%eax             ; выход
0x0000000100000ebe <main+78>:   pop    %rbx
0x0000000100000ebf <main+79>:   pop    %r12
0x0000000100000ec1 <main+81>:   leaveq
0x0000000100000ec2 <main+82>:   retq

0x0000000100000ec3 <main+83>:   mov    $0x40000000,%edi
0x0000000100000ec8 <main+88>:   callq  0x100000ef8 <dyld_stub__Znam>
0x0000000100000ecd <main+93>:   mov    %rax,%rbx
0x0000000100000ed0 <main+96>:   jmp    0x100000eac <main+60>

; Реализация на обычных командах.

0x0000000100000ed2 <main+98>:   movb   $0x0,(%rax)             ; mode = 3
0x0000000100000ed5 <main+101>:  mov    $0x1,%eax
0x0000000100000eda <main+106>:  nopw   0x0(%rax,%rax,1)
0x0000000100000ee0 <main+112>:  movb   $0x0,(%rax,%rbx,1)
0x0000000100000ee4 <main+116>:  inc    %rax
0x0000000100000ee7 <main+119>:  cmp    $0x40000000,%rax
0x0000000100000eed <main+125>:  jne    0x100000ee0 <main+112>

0x0000000100000eef <main+127>:  movsbl (%rbx),%eax             ; выход
0x0000000100000ef2 <main+130>:  pop    %rbx
0x0000000100000ef3 <main+131>:  pop    %r12
0x0000000100000ef5 <main+133>:  leaveq
0x0000000100000ef6 <main+134>:  retq

Видно, что благодаря оптимизации, ветки 1, 2 и 4 реализованы одинаково - через memset(). Вызов fill() в ветке 4 удалось свести к memset().

Но вот ветка 3 реализована в виде ручного цикла. Компилятор, конечно, неплохо поработал – цикл практически идеальный, но это все равно работает медленнее, чем хитрый memset(), который использует всякие ухищрения групповых ассемблерных операций.

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

Мораль? И мораль тут не очень хорошая.

Мне кажется, что количество людей, которые напишут std::fill(buf, buf + n, 0), разительно больше, чем std::fill(buf, buf + n, '\0').

А разница весьма существенна.

Посты по теме:

• fill_n vs memset