Инкрементът цяло число атомно ли е в x86?

Машинната инструкция за увеличаване на паметта на X86 е атомарна само ако я използвате с префикс LOCK.

x++ в C и C++ няма атомарно поведение. Ако направите отключени увеличения, поради състезания, в които процесорът чете и записва X, ако два отделни процесора се опитат да направят увеличение, можете да се окажете само с едно увеличение или и двете (вторият процесор може да е прочел първоначалната стойност, увеличена и го записва обратно, след като първият записва своите резултати обратно).

Вярвам, че C++11 предлага атомни увеличения и повечето компилатори на доставчици имат идиоматичен начин да предизвикат атомно увеличение на определени вградени цели числа (обикновено int и long); вижте справочното ръководство на вашия компилатор.

Ако искате да увеличите "голяма стойност" (да речем, цяло число с много точност), трябва да го направите с помощта на някакъв стандартен заключващ механизъм, като например семафор.

Имайте предвид, че трябва да се тревожите и за атомарните четения. На x86 четенето на 32- или 64-битова стойност се оказва атомарно, ако е подравнена с 64-битова дума. Това няма да е вярно за „голяма стойност“; отново ще ви трябва стандартна ключалка.

Ето едно доказателство, че не е атомарно в конкретно изпълнение (gcc). Както можете да видите (?), gcc генерира код, който

1. зарежда стойността от паметта в регистър
2. увеличава съдържанието на регистъра
3. записва регистъра обратно в паметта.

Това е много далеч от това да е атомно.

$ cat t.c
volatile int a;

void func(void)
{
    a++;
}
[19:51:52 0 ~] $ gcc -O2 -c t.c
[19:51:55 0 ~] $ objdump -d t.o

t.o:     file format elf32-i386


Disassembly of section .text:

00000000 <func>:
   0:   a1 00 00 00 00          mov    0x0,%eax
   5:   83 c0 01                add    $0x1,%eax
   8:   a3 00 00 00 00          mov    %eax,0x0
   d:   c3                      ret

Не се заблуждавайте от 0x0 в инструкцията mov, там има място за 4 байта и линкерът ще попълни получения адрес на паметта за a там, когато този обектен файл е свързан.

Тъй като никой не е отговорил на действителния ви въпрос и вместо това ви показва как да го направите по начин, който винаги работи:

Нишка 1 зарежда стойност 0

Нишка 2 зарежда стойност 0

Нишка 1 увеличава и съхранява 1

Нишка 2 увеличава своето локално регистърно копие на стойност и съхранява 1.

Както можете да видите, крайният резултат е стойност, равна на 1, а не на 2. Не винаги ще бъде 2 в края.

Не е гарантирано. Можете да използвате инструкцията lock xadd, за да постигнете същия ефект, или да използвате C++ std::atomic, или да използвате #pragma omp atomic, или произволен брой други решения за едновременност, които са написани, за да ви спестят неприятностите да преоткривате колелото.