u128

[amarao]

u128 (без всяких доп.трюков) сделало почти чудо, да.

На форуме мне показали bytemuck, позволяющий сделать "запретное" в расте и кастануть [u8] к [u128] с правильным пересчётом размера.

Итог:

noise fill 2560x1440    time:   [2.2220 ms 2.2227 ms 2.2239 ms]                                  
                        change: [-88.993% -88.989% -88.984%] (p = 0.00 < 0.05)
                        Performance has improved.

2.2ms на полное наполнение 2560х1440 (x4), это 454 раз за секунду, более чем достаточно для практических задач шума.

Собственно, это же подтверждается и практическим замером: 100% шума в каждом кадре даёт 260 FPS.

Итого:

1) u128
2) #[inline(always)]

... И ещё одно доказательство тезиса, что не-многопроцессные оптимизации лучше. От 6 тредов я бы получил максимум 5x улучшение, а тут - 9-кратное, причём, практически, без крупноархитектурных усложнений.

Сам код тут: https://github.com/amarao/sdl_random

Comments

[amarao]

Я очень плохо читаю ассемблер x86_64. Вроде бы, вот это, хотя я не понимаю, что это значит.

let res = self.factor.to_ne_bytes()[self.byte as usize];
lea     rdx, [rip, +, .L__unnamed_1]
mov     esi, 16
mov     rdi, rcx

(первая строчка - rust, дальше asm).

[ufm]

А если не трудно - можно еще чуть сверху/снизу показать?

[amarao]

Там дофига инлайнинга.

pub fn next(&mut self) -> u8{
sub     rsp, 24
let res = self.factor.to_ne_bytes()[self.byte as usize];
mov     rdx, qword, ptr, [rdi]
mov     r8, qword, ptr, [rdi, +, 8]
mov     qword, ptr, [rsp, +, 16], r8
mov     qword, ptr, [rsp, +, 8], rdx
let res = self.factor.to_ne_bytes()[self.byte as usize];
movzx   ecx, byte, ptr, [rdi, +, 16]
cmp     rcx, 15
let res = self.factor.to_ne_bytes()[self.byte as usize];
ja      .LBB1_4
mov     al, byte, ptr, [rsp, +, rcx, +, 8]
self.byte = self.byte + 1;
add     ecx, 1
mov     byte, ptr, [rdi, +, 16], cl
if self.byte == 16 {
cmp     cl, 16
jne     .LBB1_3
self.factor ^= self.factor << 17;
mov     rcx, r8
shld    rcx, rdx, 17
mov     rsi, rdx
shl     rsi, 17
self.factor ^= self.factor << 17;
xor     rsi, rdx
xor     rcx, r8
self.factor ^= self.factor >> 5;
mov     r8, rcx
shr     r8, 5
self.factor ^= self.factor >> 5;
xor     r8, rcx
self.factor ^= self.factor >> 5;
shld    rcx, rsi, 59
self.factor ^= self.factor >> 5;
xor     rcx, rsi
self.factor ^= self.factor << 44;
mov     rsi, r8
shld    rsi, rcx, 44
mov     rdx, rcx
shl     rdx, 44
self.factor ^= self.factor << 44;
xor     rdx, rcx
xor     rsi, r8
mov     qword, ptr, [rdi, +, 8], rsi
mov     qword, ptr, [rdi], rdx
self.byte = 0;
mov     byte, ptr, [rdi, +, 16], 0
.LBB1_3:
}
add     rsp, 24
ret
.LBB1_4:
let res = self.factor.to_ne_bytes()[self.byte as usize];
lea     rdx, [rip, +, .L__unnamed_1]
mov     esi, 16
mov     rdi, rcx
call    qword, ptr, [rip, +, _ZN4core9panicking18panic_bounds_check17hbb9512a833bf2248E@GOTPCREL]
ud2

[ufm]

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

[amarao]

Ага. Я после недавнего срачика на тему fdiv'а (когда выяснилось, что компилятор на 0.5 умножал вместо деления), часто заглядываю в ассемблер. Чаще всего всего не нахожу ничего из того, что было написано.

[ufm]

Впрочем - не надо. Я сам позаморачивался...