[.NET] Является ли получение/запись элемента массива по индексу атомарной операцией?

Question

[Exvel]

В различных коллекциях .NET индексаторы являются свойствами и понятно, что получение или установка элемента по индексу является не атомарной операцией в этом случае.
Мне интересно, есть ли в данном случае исключение для массивов?
Может ли такая операция иметь право на жизнь или же обращение через индексатор и установка назад может быть прервана переключением контекста?

int original = Interlocked.CompareExchange(ref array[2], 5, 3);

Ссылка на массив не меняется, изменяются только значения элементов в ячейках разными потоками.

Update:
Судя по всему сгенерированный IL-код обращается с переменной массива как с любой другой переменной:

IL_0017: ldloc.0      // 'array'
IL_0018: ldc.i4.2     
IL_0019: ldelema      [mscorlib]System.Int32
IL_001e: ldc.i4.5     
IL_001f: ldc.i4.3     
IL_0020: call         int32 [mscorlib]System.Threading.Interlocked::CompareExchange(int32&, int32, int32)
IL_0025: pop

Я склоняюсь все же к тому, что операция атомарная, но лучше узнать мнение знающего человека.

Answer 1

[MrDywar Pichugin]

IL код, это только половина дела.
Важна версия VM и битности сборки, debug/release режим.
Используйте windbg, там можно посмотреть код метода который будет выполнен CPU.

Я не отвечаю на вопрос, но даю информацию для размышления.
Книга - "Голдштейн С. - Оптимизация приложений на платформе .NET - 2014".

Выдержки из книги:
"Запись 32-разрядного целого числа всегда выполняется атомарно. Это означает, что, если процессор записывает в ячейку памяти значение 0xdeadbeef, прежде инициализированную нулем, другой процессор никогда не получит частично измененное значение в этой ячейке."

"К сожалению, то же самое нельзя сказать о более объемных данных; например, даже на 64-разрядном процессоре операция записи 20 байт не является атомарной и не может быть атомарной."

"Всякий раз, когда для выполнения операции с областью памяти требуется выполнить несколько инструкций, немедленно возникает проблема синхронизации. Например, операция ++i (где i является переменной на стеке типа int) обычно транслируется в последовательность из трех машинных инструкций:

   

 mov еах, dword ptr [ebp-64] ; скопировать со стека в регистр
    inc еах ;                                        увеличить значение в регистре
    mov dword ptr [ebp-64], еах ; скопировать из регистра на стек

Каждая из этих инструкций выполняется атомарно, но без дополнительной синхронизации есть вероятность, что два процессора вы­полнят части этой последовательности инструкций конкурентно. Это состояние гонки "race condition".

Все семейства процессоров, на которых Windows может выполняться, поддерживают аппаратный примитив синхронизации с названием «Сравнить-и-Заменить» (Compare-And-Swap, CAS).

В процессорах Intel х86 этот примитив реализован в виде инструкции LOCK cmpxchg. В .NET Framework примитив CAS реализован в виде множества перегруженных методов Interlocked.CompareExchange.

// Код на С#:
    int n = . . .;
    if (Interlocked.CompareExchange(ref n, 1, 0) = 0) ( // заменить 0 на 1
      // ...выполнить некоторые операции
    }
    // инструкции на языке ассемблера х8б:
    mov еах, 0 ;
    mov edx, 1 ;
    lock cmpxchg dword ptr [ebp-64], edx ;
    test eax, eax ;
    i
    jnz not__taken
    // ... выполнить некоторые операции
    not_taken:

"

Comments

[Exvel]

Спасибо за развернутый ответ. По большей части про это всё в курсе. Насчет, WinDbg мне не очень понятно как посмотреть инструкцию процессора, если IL-код компилируется в машинный во время выполнения. Или там есть такая возможность?

[MrDywar Pichugin]

Exvel: Есть, я смотрел когда увлекался.
XXX - адрес.

!dumpil XXX - IL код метода (указать MethodDesc).
!u XXX - ассемблерный код (указать MethodDesc).

Немного команд тут https://habrahabr.ru/post/260047/

[Exvel]

MrDywar Pichugin: Получил вот такой результат дизассемблирования. Не силён в ассемблере. Вроде, там перед вызовом метода пушится в стек указатель на адрес памяти указывающий на ячейку массива. Т.е., вроде бы, CompareExchange() должна атомарно этот адрес сравнить и, в случае успеха сравнения, поменять на новый.

Interlocked.CompareExchange(ref array[2], 5, 3);
00000062 mov eax,dword ptr [ebp-40h]
00000065 cmp dword ptr [eax+4],2
00000069 ja 00000070
0000006b call 6A5F1DD8
00000070 lea eax,[eax+10h]
00000073 mov dword ptr [ebp-54h],eax
00000076 push 3
00000078 mov ecx,dword ptr [ebp-54h]
0000007b mov edx,5
00000080 call 6A5C7038
00000085 mov dword ptr [ebp-4Ch],eax
00000088 nop

[MrDywar Pichugin]

Exvel: Давно не читал его тоже, но тут думаю понятно что такое количество операций не может быть атомарным. При том что нигде не видно "lock cmpxchg".
Описание команд - https://en.wikipedia.org/wiki/X86_instruction_listings

Проще в lock() засунуть такое действие.

Я в этом не очень разбираюсь, не приходилось использовать на практике, так что все перепроверять нужно.

Вот такой вопрос на SA stackoverflow.com/questions/154551/volatile-vs-int...

Jon Skeet пишет:
I'm happy to use Interlocked for the cases of a single variable where it's obviously okay. When it gets more complicated, I'll still revert to locking.

Для одной переменной и одной операции Interlocked хорош, в другом случае лучше использовать lock.

[Exvel]

MrDywar Pichugin: Я просто к тому, что перед вызовом CompareExchange() (call 6A5C7038) стек уже имеет указатель на область памяти массива. Соответственно во время вызова CompareExchange() как раз и должна единоразово выполниться инструкция "lock cmpxchg": считать переменную по указателю, сравнить и заменить - все это как атомарная операция.