newuser8888

Просто нужно создать новую хэш-таблицу в 20 миллиардов и всё? Ведь это делается за секунды.

1. Даже просто выделить память на 20 миллиардов хешей займет далеко не секунды.
2. Не секунды займет записать их на диск.
3. Соль нужна для того, чтобы нельзя было использовать РАНЕЕ сгенеренную хеш таблицу.
4. md5 не самый лучший хеш на сегодня - можно использовать более трудоемкое хеширование, которое будет генерироваться медленнее.

В общем соль нужна именно для того, чтобы обеспечить противодействие радужным таблицам. Все.

1. Округление к чётному. Это стандартное округление к ближайшему; если расстояние одинаково — то к чётному.
4,4 → 4
4,5 → 4
4,6 → 5
−4,4 → −4
−4,5 → −4
−4,6 → −5
5,4 → 5
5,5 → 6
5,6 → 6
−5,4 → −5
−5,5 → −6
−5,6 → −6

2. Округление вниз к −∞. Округление к меньшему.
4,xxx → 4 (при любой дробной части)
−4,xxx → −5

3. Округление вверх к +∞. Округление к бóльшему.
4,xxx → 5
−4,xxx → −4

4. Отбрасывание дробной части. Округление к 0. Округление к меньшему по модулю.
4,xxx → 4
−4,xxx → −4

Столько много знаков у double — так что где-то в недрах библиотеки float стал double’ом. Знаков у float не точно 7, а чуть больше семи. И это число действительно не тройка: тройка имеет 16-й вид 4040.0000, а ваше число — 403F.FFFF. Как вы видите, величина единицы младшего разряда (ULP) на таких величинах будет около 2,4·10⁻⁷ — поболее семи знаков будет, но до восьми не дотягивает.

Механизмы округления IEEE 754 не имеют никакого отношения к десятичному округлению, прописанному в библиотеке языка. Округление IEEE на самом деле двоичное и используется при переводе из более точного типа в менее точный, или чтобы округлить результат умножения/деления.

Оригинальный код прекрасно работает как есть:

$ gcc -nostartfiles -static str.s -o str
$ gdb ./str
...
(gdb) b *0x40102f
Breakpoint 1 at 0x40102f
(gdb) r
Starting program: /home/jcmvbkbc/tmp/toster/str 

Breakpoint 1, 0x000000000040102f in _start ()
(gdb) x/3b $rsi - 3
0x402000 <source>:      1       2       3
(gdb) x/3b $rdi - 3
0x402010 <dest>:        1       2       3

Почему не работает

leaw arrayW, %si
movw (%si), %ax

Потому что ты в 32-битной программе пытаешься адресоваться 16-битным регистром.
Вот так всё прекрасно работает:

leal arrayW, %esi
movw (%esi), %ax

:

$ gcc -m32 -static -nostartfiles load.s -o load
$ gdb ./load
(gdb) b _start
Breakpoint 1 at 0x8049000
(gdb) r
Starting program: /home/jcmvbkbc/tmp/toster/load

Breakpoint 1, 0x08049000 in _start ()
(gdb) si
0x08049006 in _start ()
(gdb) 
0x08049009 in _start ()
(gdb) p/x $esi
$1 = 0x804a000
(gdb) p/x $ax
$2 = 0x5

Кратко так - представь, что ты рисуешь треугольник в начале координат (0, 0). Поверни его вокруг начала координат (матрицей поворота), и затем смести его так, чтобы координаты конца отрезка совпали с координатами вершины треугольника. Для этого просто прибавь dx и dy.

В те стародавние времена контроллер памяти был в северном мосту, с CPU северный мост связывался по шине FSB.
FSB оно 64-битная штука во времена core 2 quad, эффективно учетверённая частота базового генератора, 4 порции данных передаётся за такт - потому маркетинг решил назвать 1333мгц вместо 333мгц (что есть в реальности).
память тоже на 64-битной шине, на удвоенной частоте базового генератора. DDR2-800 - 400мгц шина. Два канала - соответственно 2 шины по 64 бита.

Итого, если вас интересует только полоса пропускания - простым математическим подсчётом получается что нет никакого смысла ставить память с частотой выше (и, соответственно, 1:1 делителя). Два канала памяти на удвоенной частоте базового генератора (2 * 2 * 64 бита) как раз соответствуют возможностям одной FSB на учетверённой эффективной частоте (4 * 64 бита)
Но в то же время в этом некоторый смысл может быть, если смотреть на латентность. Вы не сможете прокачать больше данных - FSB ограничивает, но вы сможете получать данные из RAM с меньшей латентностью.

Есть ли какая-то разница?

Разница в том, что инициализация bool full = false; выполняется для любого конструктора, у которого поле full не перечислено в списке инициализации.
Конечное состояние конструируемого объекта одинаково в обоих случаях.

И почему так конструктор не работает:

Потому что у класса Token отсутствует конструктор по умолчанию.

синтаксис стрелочной функции: () => {}, если аргумент один - можно упустить скобки, если это не добавит неоднозначности при интерпретации, также и про тело функции, если одна операция, можно упустить фигурные скобки, беря во внимание то, что ее результат будет возвращен как результат работы функции. Допустим уберем скобки у аргумента, он же по сути один, запись будет выглядеть так:
filter({ name } => ...);
откуда интерпретатору понять, хотел ли ты передать в качестве аргумента объект { name }, который развернется потом в { name: name }, тогда дальнейший код будет невалидным

filter(/* передать объект как аргумент можно */{ name: name } /*   а дальнейшее не валидно -> */  => ...)

, или же это стрелочная функция, чтоб дать понять интерпретатору, что ты имеешь ввиду передаваемый объект как аргумент, будь добр - оберни список аргументов, как это подобает исходному синтаксису стрелочных функций