깊은 산 속 곰탱군

XOR Swap Algorithm

곰ⓣing — Mon, 14 Apr 2008 23:45:18 +0900

XOR swap algorithm

From Wikipedia, the free encyclopedia

In computer programming, the XOR swap is an algorithm that uses the XOR bitwise operation to swap distinct values of variables having the same data type without using a temporary variable.

1 The algorithm
2 Proof that XOR swap works
3 Code example
4 Reasons for use in practice
5 Reasons for avoidance in practice
- 5.1 The XCHG instruction
- 5.2 Aliasing
6 Variations
7 See also

The algorithm

Standard swapping algorithms require the use of a temporary storage variable. Using the XOR swap algorithm, however, no temporary storage is needed. The algorithm is as follows:

X := X XOR Y
Y := X XOR Y
X := X XOR Y

The algorithm typically corresponds to three machine code instructions. For example, in IBM System/370 assembly code:

XR    R1,R2
XR    R2,R1
XR    R1,R2

where R1 and R2 are registers and each XR operation leaves its result in the register named in the first argument.

However, the problem still remains that if x and y use the same storage location, the value stored in that location will be zeroed out by the first XOR instruction, and then remain zero; it will not be "swapped with itself". (Note that this is *not* the same as if x and y have the same values. The trouble only comes when x and y use the same storage location.)

Proof that XOR swap works

The binary operation XOR over bit strings has the following properties (where denotes XOR):

L1. Commutativity:
L2. Associativity:
L3. Identity exists: there is a value $Z = 0$ such that for any $A$
L4. Each element has an inverse: for each A, there is a value such that
- L4a. In fact, each element is its own inverse: .

The first four properties are the definition of an Abelian group. The last is a structural feature of XOR not necessarily shared by other Abelian groups or groups in general.

Suppose that we have two registers R1 and R2, as in the table below, with initial values A and B respectively. We perform the operations below in sequence, and reduce our results using the property list above.

Step	Operation	Register 1	Register 2	Reduction
1	Initial value	A	B	—
2	`R1 := R1 ^ R2`	A^B	B	—
3	`R2 := R1 ^ R2`	A^B = B^A	(A^B)^B = A^(B^B) = A^0 = A	L1, L2, L4, L3
4	`R1 := R1 ^ R2`	(B^A)^A = B^(A^A) = B^0 = B	A	L2, L3, L4

Code example

A C function that implements the XOR swap algorithm:

void xorSwap (int *x, int *y)
{
    if (x != y) {
        *x ^= *y;
        *y ^= *x;
        *x ^= *y;
    }
}

Note that the code does not swap the integers passed immediately, but first checks if their memory locations are distinct. This will remove problems caused by possible aliasing.

The body of this function is sometimes seen incorrectly shortened to if (x != y) *x^=*y^=*x^=*y;. This may not obtain desired result because of a lack of sequence points; No evaluation order was given for the assignments.

Reasons for use in practice

The algorithm is not uncommon in embedded assembly code, where there is often very limited space available for a temporary swap variable, and this form of swap can also avoid a load/store which can be much faster than the equivalent operation using a temporary variable. On some architectures, certain operations require their operands to be in particular registers, requiring a swap; and all available "temporary" registers may be in use storing other data. Some optimizing compilers can generate code using XOR swap in these situations.^{[citation needed]}

Reasons for avoidance in practice

On modern (desktop) CPUs, the XOR technique is considerably slower than using a temporary variable to do swapping. One reason is that modern CPUs strive to execute commands in parallel; see Instruction pipeline. In the XOR technique, the inputs to each operation depend on the results of the previous operation, so they must be executed in strictly sequential order. If efficiency is of tremendous concern, it is advised to test the speeds of both the XOR technique and temporary variable swapping on the target architecture.

The XCHG instruction

Modern optimizing compilers work by translating the code they are given into an internal flow-based representation which they transform in many ways before producing their machine-code output. These compilers are more likely to recognize and optimize a conventional (temporary-based) swap than to recognize the high-level language statements that correspond to an XOR swap. Many times, what is written as a swap in high-level code is translated by the compiler into a simple internal note that two variables have swapped memory addresses, rather than any amount of machine code. Other times, when the target architecture supports it, the compiler can use a single XCHG (exchange) instruction which performs the swap in a single operation.

An XCHG operation was available as long ago as 1964, on the PDP-6 (where it was called EXCH) and in 1970 on the Datacraft 6024 series (where it was called XCHG). The Intel 8086, released in 1978, also included an instruction named XCHG. All three of these instructions swapped registers with registers, or registers with memory, but were unable to swap the contents of two memory locations. The Motorola 68000's EXG operation can only swap registers with registers. The PDP-10 inherited the PDP-6's EXCH instruction, but the PDP-11 (the machine on which the C programming language was developed) did not.

However, the XCHG instruction in modern processors (e.g. x86) should only be used to swap registers and not memory, as an implicit LOCK instruction may be imposed by the processor on the memory location(s) involved so that the operation is atomic.

Aliasing

The XOR swap is also complicated in practice by aliasing. As noted above, if an attempt is made to XOR-swap the contents of some location with itself, the result is that the location is zeroed out and its value lost. Therefore, XOR swapping must not be used blindly in a high-level language if aliasing is possible.

Variations

The underlying principle of the XOR swap algorithm can be applied to any reversible binary operation. Replacing XOR by addition and subtraction gives a slightly different, but largely equivalent, formulation:

procedure AddSwap (var X, Y: integer);
begin
  if X <> Y then begin
    X := X + Y;
    Y := X - Y;
    X := X - Y
  end
end

Unlike the XOR swap, this variation requires that the underlying processor or programming language uses a method such as modular arithmetic or bignums to guarantee that the computation of X + Y cannot cause an error due to integer overflow. Therefore, it is seen even more rarely in practice than the XOR swap.

마비노기 환생 이벤트!

곰ⓣing — Thu, 6 Mar 2008 19:39:31 +0900

올해(2008년)동안 접속이 없었던 사용자들을 대상으로 환생 쿠폰을 준다.

이제부터 다시 마비노기의 세계로...하루 2시간씩 빠져보는거다 -ㅅ-;

근데 기껏 유료 계정 넣고 팔라딘 변신 배워놨더니...

무료 사용자라고 변신도 못해 ㅠ_ㅠ

돈독오른 넥슨 지금 장난하니? :(

Flash와 Silverlight..

곰ⓣing — Thu, 6 Mar 2008 17:19:41 +0900

RIA 플랫폼이다.

하나는 어도비꺼, 하나는 MS꺼.

최근 MS에서 플래시를 따라잡으려고 노력을 많이 하는데 과연 성공할런지?

이쪽 시장까지 MS가 먹고 나면 뭐..할 말이 없구만.

그렇다고 이제와서 웹을 뒤엎을만한 새로운 트렌드의 서비스 개념을 성공시키기는 힘들테고.

역시 돈 있는 놈이 돈 먹는 세상이다..쳇.

삼성 떡값 사건? 삼성 뇌물수수 사건!

곰ⓣing — Thu, 6 Mar 2008 14:20:30 +0900

언론이 자기네 편이면 좋은 이유.

알아서 단어 순화를 해준다.

삼성 떡값 사건이라니.

이게 무슨 동네 애들이 장난치다 걸린건가?

삼성 뇌물수수 사건이라고 해야지.

단어에서조차 부정적인 이미지를 가리려고 난리치는 삼성. -_-

하긴, 태안사건에서는 유조선의 선박명 '허베이스피리트'은 거의 대부분의 기사에 실렸지만..

인양선과 부선의 선박명..삼성3호, 삼성5호던가? 이건 실린데도 몇군데 없었지.

이제 법정공방에선 정박해있었던 유조선이 자기네들쪽으로 돌진해왔다고 주장하는 삼성...-_-;

We've got everything!

곰ⓣing — Wed, 5 Mar 2008 19:17:01 +0900

Modest mouse - We've got everything.

We've got everything
We've got everything
We've got everything down to a science so I guess we know everything
We know everything
We know everything
We know everything was built to expire so I guess we've done everything
If we carried it out to sea
Pushed it over the edge we'd have all been through,
Well first off Gary got drunk fell asleep in his car til about noon
Flat Top Tony got all messed up split his lip chasing cheap perfume
Well look at our boat in the bay it looks like some sad ass little canoe
We've done everything
We've done everything
We've done everything like trial by fire so I guess we'll stop trying now
We've tried everything
We've tried everything
We've tried everything half assed and as liars and thats how we've got everything
If we carried it out to sea pushed it over the edge we could have all been through
Well no one even bothered showin' up but we still did what we should have thought through
We crashed in like waves into the stars Didn't want it didn't need it but we knew that we
Could see it so we opened up the door
We receded like waves out of the stars
Didn't want it didn't need it but we knew that we could steal it left it dying on the
Floor
We've got everything
We've got everything
We've got everything down to a science so I guess we know everything
We've got everything
We've done everything
We've tried everything
We've got everything
We've got everything

2009년 공휴일..

곰ⓣing — Wed, 5 Mar 2008 19:06:55 +0900

설 연휴 : 일, 월, 화
삼일절 : 일요일
어린이날 : 화요일 (그나마 다행)
현충일 : 토요일
제헌절 : 금요일 ( 이건 굿! )
광복절 : 토요일
개천절 : 토요일
추석 : 개천절과 겹치는데다가 금, 토, 일 -_-; ( 최악! )
크리스마스 : 금요일 (마지막은 그나마..)

즉, 2009년에 공휴일다운 공휴일은 달랑 3일이다.

2009년엔 회사 때려치우고 알바나 하면서 살까나.

제9회 한국 자바 개발자 컨퍼런스

곰ⓣing — Mon, 11 Feb 2008 16:09:11 +0900