Что вы имеете в виду под атомными инструкциями?
Как следующее становится атомарным?
TestAndSet
int TestAndSet(int *x){
register int temp = *x;
*x = 1;
return temp;
}
С точки зрения программного обеспечения, если кто-то не хочет использовать неблокирующие примитивы синхронизации, как можно обеспечить атомарность инструкции? возможно ли это только на Аппаратном уровне или может использоваться некоторая директивная оптимизация на уровне сборки?
Некоторые машинные инструкции по сути являются атомарными - например, чтение и запись правильно выровненных значений размера слова собственного процессора является атомарным на многих архитектурах.
Это означает, что аппаратные прерывания, другие процессоры и гиперпотоки не могут прерывать чтение или сохранение и чтение или запись частичного значения в одно и то же место.
Более сложные вещи, такие как чтение и запись вместе атомарно, могут быть достигнуты с помощью явных атомных машинных инструкций, например. ЗАБЛОКИРОВАТЬ CMPXCHG на x86.
Блокировка и другие высокоуровневые конструкции построены на этих элементарных примитивах, которые обычно охраняют только одно слово процессора.
Некоторые умные параллельные алгоритмы могут быть построены с использованием только чтения и записи указателей, например. в связанных списках, совместно используемых одним читателем и писателем, или, при необходимости, несколькими читателями и писателями.
Атомик происходит от греческого ἄτομος (атомос), что означает «неделимый». (Предостережение: я не говорю по-гречески, так что, возможно, это действительно что-то другое, но большинство англоговорящих людей, ссылаясь на этимологию, интерпретируют это так. :-)
В вычислениях это означает, что операция происходит. Нет никакого промежуточного состояния, которое было бы видимым до его завершения. Поэтому, если ваш ЦП прерывается для обслуживания оборудования (IRQ), или если другой ЦП читает ту же самую память, это не влияет на результат, и эти другие операции будут считать его завершенным или не запущенным.
В качестве примера ... предположим, вы хотите установить переменную для чего-то, но только если это не было установлено ранее. Возможно, вы захотите сделать это:
if (foo == 0)
{
foo = some_function();
}
Но что, если это будет выполняться параллельно? Может случиться так, что программа получит foo, увидит его как ноль, в то время как поток 2 делает то же самое и устанавливает какое-то значение. Вернувшись в исходный поток, код по-прежнему считает, что foo равен нулю, и переменная назначается дважды.
Для подобных случаев ЦП предоставляет некоторые инструкции, которые могут выполнять сравнение и условное присвоение как атомарную сущность. Следовательно, test-and-set, compare-and-swap и load-connected / store-conditional. Вы можете использовать их для реализации блокировок (ваша ОС и ваша библиотека C сделали это). Или вы можете написать разовые алгоритмы, которые полагаются на примитивы, чтобы что-то делать. (Здесь есть кое-что интересное, но большинство простых смертных избегают этого, опасаясь ошибиться.)
Ниже приведены некоторые из моих заметок об атомарности, которые могут помочь вам понять значение. Примечания взяты из источников, перечисленных в конце, и я рекомендую прочитать некоторые из них, если вам нужно более подробное объяснение, а не точечные маркеры, как у меня. Пожалуйста, укажите на любые ошибки, чтобы я мог их исправить.
Определение:
Пример 1. Атомарные операции
Рассмотрим следующие целые числа, используемые разными потоками:
int X = 2;
int Y = 1;
int Z = 0;
Z = X; //Thread 1
X = Y; //Thread 2
В приведенном выше примере два потока используют X, Y и Z
Пример 2: Неатомарные операции: ++ / - Операции
Рассмотрим выражения увеличения / уменьшения:
i++; //increment
i--; //decrement
Операции переводятся в:
Пример 3. Неатомарные операции: значения больше 4 байтов
struct MyLong { public readonly int low; public readonly int high; public MyLong(int low, int high) { this.low = low; this.high = high; } }
MyLong X = new MyLong(0xAAAA, 0xAAAA); MyLong Y = new MyLong(0xBBBB, 0xBBBB); MyLong Z = new MyLong(0xCCCC, 0xCCCC);
X = Y; //Thread 1 Y = X; //Thread 2
В .NET при копировании типа значения среда CLR не вызывает конструктор - она перемещает байты по одной атомарной операции за раз.
X.low = Y.low; //Thread 1 - X = 0xAAAABBBB Y.low = Z.low; //Thread 2 - Y = 0xCCCCBBBB Y.high = Z.high; //Thread 2 - Y = 0xCCCCCCCC X.high = Y.high; //Thread 1 - X = 0xCCCCBBBB <-- corrupt value for X
Чтение и запись значений, превышающих 32-битные, в нескольких потоках в 32-битной операционной системе без добавления какой-либо блокировки, чтобы сделать операцию атомарной, вероятно, приведет к повреждению данных, как указано выше.
Операции процессора
На всех современных процессорах можно предположить, что чтение и запись естественно выровненных собственных типов являются атомарными до тех пор, пока:
На x86 и X64 нет гарантии, что чтение и запись размером более восьми байт являются атомарными.
Языковые различия
C #
using System.Threading; int unsafeCount; int safeCount; unsafeCount++; Interlocked.Increment(ref safeCount);
C ++
struct AtomicCounter
{std::atomic< int> value; void increment(){ ++value; } void decrement(){ --value; } int get(){ return value.load(); }}
Java
import java.util.concurrent.atomic.AtomicInteger; public class Counter { private AtomicInteger value= new AtomicInteger(); public int increment(){ return value.incrementAndGet(); } public int getValue(){ return value.get(); } }
Атомарность - это ключевая концепция, когда у вас есть любая форма параллельной обработки (включая различные приложения, взаимодействующие или обменивающиеся данными), которая включает общие ресурсы.
Проблема хорошо проиллюстрирована на примере. Допустим, у вас есть две программы, которые хотят создать файл, но только если файл еще не существует. Любая из двух программ может создать файл в любой момент времени.
Если вы это сделаете (я буду использовать C, так как это то, что в вашем примере):
...
f = fopen ("SYNCFILE","r");
if (f == NULL) {
f = fopen ("SYNCFILE","w");
}
...
вы не можете быть уверены, что другая программа не создала файл между вашим открытым для чтения и вашим открытым для записи.
Вы не можете сделать это самостоятельно, вам нужна помощь операционной системы, которая обычно предоставляет примитивы синхронизации для этой цели, или другой механизм, который гарантированно является атомарным (например, реляционная база данных, в которой операция блокировки является атомарной, или механизм более низкого уровня, такой как инструкции по «тестированию и установке» процессоров).
Атомарность может гарантировать только ОС. Для этого ОС использует базовые функции процессора.
Поэтому создание собственной функции testandset невозможно. (Хотя я не уверен, можно ли использовать встроенный фрагмент asm и использовать мнемонику testandset напрямую (может быть, этот оператор может быть выполнен только с привилегиями ОС))
РЕДАКТИРОВАТЬ: Согласно комментариям под этим сообщением, возможно создание вашей собственной функции bittestandset с использованием директивы ASM напрямую (на Intel x86). Однако неясно, работают ли эти уловки и на других процессорах.
Я придерживаюсь своей точки зрения: если вы хотите делать неприятные вещи, используйте функции ОС и не делайте этого самостоятельно.
