Here is really basic assembly for a normal swap, using two registers (found it by looking elsewhere on GameDev, posted by Prosper/LOADED):

inline void swap(int& a, int& b){  asm  {    mov   eax, a    mov   ebx, b    mov   b, eax    mov   a, ebx  };}

You'll notice that the first two instructions are completely independent. This means that the processor can roughly do them at the same time. The second two instructions are also completely independent. They can be done at roughly the same time as well. The second two obviously have to wait for the first two to complete of course, but each pair can occur simultaneously. Modern processors have been doing this for quite a while, and they and compilers get better at it all the time.

The XOR method does not allow this. The second operation needs to wait for the first operation to complete before it can start. The third operation also needs to wait for the second operation to complete before it can start. All this waiting means that a lot of the CPU is sitting there unused.

Graphically, the first one would look like this:

[**** OPERATION 1 ****]    [**** OPERATION 3 ****]    [**** OPERATION 2 ****]    [**** OPERATION 4 ****]

The second one (XOR) would look more like this:

[**** OPERATION 1 ****][**** OPERATION 2 ****][**** OPERATION 3 ****]

So you can see how the XOR ends up taking longer, even though it has one less operation.

Quote:Original post by load_bitmap_file
Creating a temporary is actually faster than using XOR?! I thought bitwise operations were supposed to be really fast.

http://www.gamedev.net/reference/programming/features/bitwise/page4.asp
(ctrl + f "swapping variables")

^ Where I got my information from.

Well, they are, and movs are just as fast. So basically if you do something like this:

;; Swap eax and ebxmov edx, eax ; u pipe \__ 1 clock!mov ecx, ebx ; v pipe /mov ebx, edx ; u pipe \__ 1 clock!mov eax, ecx ; v pipe /

They're perfectly paired, no stalls.

;; Swap eax and ebxxor eax, ebx ; u pipe --- 1 clock!;; STALL, not paired, write after read (ebx)xor ebx, eax ; u pipe --- 1 clock!;; STALL, not paired, write after read (eax)xor eax, ebx ; u pipe --- 1 clock!

Now, in the first method (temp swap) the C compiler will likely notice that you're swapping with a temp and replace it with xchg eax, ebx if it's relatively smart. A not-so-smart compiler might ignore the XOR-swap and just turn it into a bunch of XORs (ick).

;; Swap eax and ebxxchg eax, ebx ----------- 1 clock!

Very nice.