Лучший способ атомарно обновить два члена структуры?

Если оборудование, на которое вы ориентируетесь, не поддерживает двойное сравнение и замену (что, вероятно, не так), я думаю, у вас есть только два портативных решения:

1. Введите блокировку более высокого уровня (мьютекс или спин-блокировку в зависимости от ваших предпочтений) и перенесите все операции на b и c в рамках полученной блокировки. Мьютекс тяжелый, но std::atomic_flag свободен от блокировок и очень легкий даже в ситуациях с высоким уровнем конкуренции.

2. Объедините оба элемента в один std::atomic<int> и разделите этот int на short с помощью битовой маскировки. Обратите внимание, что для этого требуется sizeof(int) >= 2 * sizeof(short). Используйте целочисленные типы фиксированного размера, если вам нужно это сделать.

Чтобы определить, какое решение самое быстрое, конечно же, тесты.

Если вы знаете, сколько struct A вам понадобится во время компиляции, я бы посоветовал поместить их в std::array. Если вы этого не сделаете, std::vector в порядке, пока это число остается постоянным на протяжении всего времени существования вектора. В противном случае, поскольку std::atomic<T> нельзя копировать или перемещать, вам нужно написать свой собственный конструктор копирования / перемещения для struct A.

Я рекомендую заключить переменные в класс с помощью геттера и сеттера, защищенного мьютексом, и сделать переменные приватными.

Использование объединения может вызвать непредвиденные функциональные возможности, основанные на архитектуре компьютера и флагах компилятора.

РЕДАКТИРОВАТЬ Результаты выполнения простой программы, хранящей значения данного типа структуры (Linux 32bit, x86):

• Простой магазин (вообще без защиты) -> ~ 4000 мкс
• Охраняемый магазин Mutex -> ~ 12000 мкс
• Использование объединения с атомным полем агрегации -> ~ 21000 мкс

Просто сделайте union достаточно большого атомарного типа. Это то, что я использую (фрагмент кода не идеально переносим, ​​использование типов <cstdint> вместо short и int, безусловно, было бы предпочтительнее, но для меня это достаточно хорошо, как есть), и он отлично работает хорошо и надежно, так как ... практически навсегда:

union A {
    struct {
         short b;
         short c;
    };

    std::atomic<int> d;
};

(На самом деле, моя реализация немного сложнее: я по привычке оборачиваю все это в другой struct, поэтому A - это struct, содержащий union, а не union. Традиционно union имел странные ограничения на конструкторы, моя первоначальная реализация предшествует C ++ 0x, и моему A нужен конструктор. Но, конечно, при использовании <atomic> C ++ 11 эти соображения полностью устаревают, поскольку этих искусственных ограничений больше не существует)

Обратите внимание, что std::atomic может быть свободным от блокировки, но не гарантируется (кроме bool). На практике для чего-либо размером int или short он не блокируется на каждой "серьезной, без шуток" архитектуре, а на большинстве современных архитектур он не блокируется и для чего-то размером с указатель (хотя существуют исключения, в частности, самое первое поколение чипов x86_64 от AMD).

Поскольку переносимость не является проблемой, блокировка настолько навязчива, насколько вы этого хотите («навязчивый» означает петлю CAS или чрезмерную блокировку).

В вашем случае вы можете напрямую использовать атомарные встроенные функции.

AFAIK, вы должны иметь возможность смешивать размеры слов, чтобы работать непосредственно с b и c, а также с a. Я никогда этого не делал, поэтому не могу сказать, будет ли это работать надежно на всех x86. Как всегда: прототип и тест, тест, тест!