I try rewrite my 32 bit example and get fasm error.
Call dword[ebx-4] illegal instruction !

How fix this ?

I plane do this:

Or using RSP ?
push dword [ebx-4]

Direct quote from AMD manual:

Roman: You don't need the "sub rdx,rdx" instruction there. All writes to edx (and all 32-bit registers) will zero the upper 32-bits automatically.

Also we discussed push previously. In 64-bit mode you can't push 32-bit values. It simply can't be done.

Make sure it fits in 32 bits...

O ! I dont know this !

I test and look in IDA Pro
mov rax,-1
mov eax,0xff00ff00 ;this reset to null high parts rax

Why this need do ? About reset high part rax.
Very handfull store in high part some values.
And exist MOVSXD

Ask AMD. They decided it.

Where was Intel ?
Smoking in the bathroom ?

They were sleeping after creating the itanium.

Intel was in Italy and created itanium.

So they can rename the register and avoid false dependencies. I've talked to you about register renaming before, but you wouldn't listen.

If the higher 4 bytes were not cleared, the CPU wouldn't be able to parallelize it: what if some earlier code modified the 4 higher bytes and you used them subsequently? It can't afford to create a wrong result.

But now it implicitly knows they are 0, so it can use a totally different register to do the calculations at the same time without waiting for it.

And how to use it on practically ?
Show simple example.

You don't "use" it, it's automatic. I don't think you understand how long the OoO pipeline is in modern CPUs.

Here's an example with a loop: Note how the second "mov eax" doesn't depend on the first one at all (it will zero the upper part), so the CPU will do it in parallel on a different physical register. The write doesn't depend on the first "mov rax" either so it runs in parallel.

Keep in mind this isn't just two things running in parallel. Each iteration of the loop runs in parallel since it's independent of another one (except for ecx, which is dirt cheap to compute, just a decrement on each iteration).

Depends how much the CPU can execute in parallel at this point, which varies by CPU design. You don't concern yourself with that, what you simply do is allow it to run it in parallel, nothing more. It could execute 2 things in parallel at same time, or 100.

That's why some CPUs are wildly faster than others, even with similar clock speeds. They execute more stuff in parallel. But obviously to do this, they need to be allowed to execute them in parallel. Register renaming is a big deal for this.

Now it can do both memory reads per loop at the same time, instead of having to wait for first memory read and other computations done.


Keep in mind that the CPU OoO execution doesn't "stop" at a jump or loop. Branch prediction is a huge thing. For loops it will correctly predict them a lot of the time.

So as far as the CPU sees, it sees a lot more of these parallel instructions than just 2: it sees the next loop iteration at the same time, then the next as well and how many it can fit in its pipeline. It executes all of them at the same time.

[quote="Furs"]
You said CPU do this parallel.
Rax on one CPU register and eax another CPU register
Physically in CPU this is two registers.
It right?


You said in this case CPU do two parallel loops.
It right ?

Exactly. It varies by CPU, but most current desktop CPUs have at least 128 physical GP registers per core. (while you can only address 8 in the ISA in non-long mode, and 16 in long mode)

The registers you access in code do not map directly to physical registers, the CPU abstracts that and uses a lot more internally due to register renaming.

Or more than two, depending how deep its capabilities are. Unroll the loop in your head, that's what the CPU "sees".

As long as it has idle execution units available, it will try to fill them up to do work at the same time, with things that don't depend on previous results.