Новая книжка на моей полке

[vak]

Это такие специальные коаны для программистов.
Кто осознает глубокий смысл каждого фрагмента, достигнет нирваны.

Comments

[spamsink]

Да уж, прошли те времена, когда подобного эффекта можно было достигнуть на микрокалькуляторе Б3-18 с помощью 1+=⟷=⟷=⟷=...

[vak]

Кстати да, те калькуляторы были отличным источником премудрости. 😀

https://vak.dreamwidth.org/280343.html

[spamsink]

На Rockwell трюк работает?

[vak]

Попробую сегодня вечером.

[spamsink]

Cursor в состоянии достичь нирваны:

What does the sequence of x86 instructions "neg rax; sbb rax,rax; neg rax" do?

This instruction sequence is a clever branchless way to convert a value to a boolean (0 or 1):
Step-by-step breakdown:
1. neg rax - Negates rax (two's complement)
• If rax == 0: result is 0, carry flag CF = 0
• If rax != 0: result is -rax, carry flag CF = 1
2. sbb rax, rax - Subtract with borrow: rax = rax - rax - CF
• If CF == 0: rax = 0 - 0 - 0 = 0
• If CF == 1: rax = 0 - 0 - 1 = -1 (0xFFFFFFFFFFFFFFFF)
3. neg rax - Negates rax again
• If rax == 0: result is 0
• If rax == -1: result is 1

Overall effect:
• Input rax == 0 → Output rax = 0
• Input rax != 0 → Output rax = 1

This is essentially computing rax = (rax != 0) ? 1 : 0 without any branches. It's a classic trick used in performance-critical code where branch mispredictions would be costly, converting any non-zero value to exactly 1.

What does the sequence of x86 instructions ".loop: xadd rax,rdx; loop .loop" do?

This instruction sequence computes Fibonacci numbers (or a Fibonacci-like recurrence):
Breakdown:
1. xadd rax, rdx - Atomic exchange-and-add:
• Saves old rax to a temp location
• rax = rax + rdx
• rdx = temp (old value of rax)
2. loop .loop - Decrements rcx and jumps to .loop if rcx != 0

What it does:
Starting with initial values rax = A, rdx = B, rcx = N:
• Iteration 1: rax = A+B, rdx = A
• Iteration 2: rax = (A+B)+A = 2A+B, rdx = A+B
• Iteration 3: rax = (2A+B)+(A+B) = 3A+2B, rdx = 2A+B
• Iteration 4: rax = 5A+3B, rdx = 3A+2B

The coefficients follow the Fibonacci sequence!
Classic use case:
mov rax, 1; mov rdx, 0; mov rcx, N; .loop: xadd rax, rdx; loop .loop After N iterations:
• rax = F(N+2) (the (N+2)th Fibonacci number)
• rdx = F(N+1) (the (N+1)th Fibonacci number)

This is a compact, branchless way to compute Fibonacci numbers, though the loop instruction itself is somewhat slow on modern
processors, so it's more of a code golf trick than production code.

[vak]

Круто однако!
Теперь есть у кого спрашивать такие вещи. 😀

Пойду помучаю грока этим делом...

[vak]

Грок тоже не облажался. Дал те же ответы, развёрнуто, с пояснениями. Первый вопрос занял 22 секунды, второй 58 секунд. Вкратце:

This x86-64 sequence (neg rax; sbb rax, rax; neg rax) converts the original 64-bit value in RAX to 1 if it was non-zero, or 0 if it was zero. It is a branchless "boolean cast" (like !!x or (x != 0) ? 1 : 0 in C) that works for both positive and negative values.

This x86-64 sequence (.loop: xadd rax,rdx; loop .loop) is a famous 2-instruction Fibonacci generator (snippet 0x01 from xorpd’s book xchg rax, rax).
It advances the pair (RAX, RDX) along the Fibonacci recurrence exactly N times, where N = initial RCX (RCX must be > 0; RCX = 0 would infinite-loop).