Приветствую!

В моей библиотеке ядра уже есть минимальные, но работающие аллокатор, семейство vsnprintf, ctype, string.h, strings.h. Остались только атомики и спинлок, и тогда можно будет доделать семейство malloc в блокировками как того требует стандарт. Так уж вышло что в osdev-libstdc есть и библиотечные вещи для чистого С++ с шаблонами. Это разумный минимум для реализации последующих вещей необходимых хотя бы для того, что бы комфортно напечатать "Hello world" не говоря уже о том, что бы сделать минимально разумные контейнеры.

Реализация базового шаблона std::atomic со всеми перегрузками минимального набора функций из cppreference выполнена при помощи gcc atomic builtins. По сути сам шаблон является оберткой над ними. Это должно успешно работать на x86, x86_64, arm, arm64 и других поддерживаемых gcc платформх благодаря усилиям компилятора. На момент написания статьи код не скомпилируется ни чем кроме GCC. Поддержка clang планируется в будущем, но когда именно пока неизвестно :-)

Раз уж я обозреваю процесс разработки своей ОС, а не пишу учебник, в этой статье не будет подробно рассматриваться устройство кеша процессора или протокол MESI, я расскажу лишь о вещах необходимых для понимания что означают те или иные константы и зачем они нужны. Так же я расскажу почему они добавлены именно в atomic.h.

Все по порядку.

Что такое GCC Atomic Builtins?

Это набор встроенных в компилятор функций реализующих атомарный доступ к памяти примерно соответствующий модели памяти С++ 11. Тем кто смотрел в код std::atomic в libstdc++ gcc уже известно, что эти функции используются в реализации std::atomic. По сути моя реализация делает тоже самое, только более прямолинейно.

В реализации я использую следующие встроенные константы и функции GCC:

__ATOMIC_RELAXED

Операция атомарна, но не накладывает дополнительных ограничений на порядок других операций памяти.

__ATOMIC_ACQUIRE

Acquire-операция. Если она читает значение, записанное release-операцией, то образуется synchronizes-with / inter-thread happens-before связь.

Не позволяет последующим операциям чтения и записи быть переупорядоченными перед acquire-операцией.

__ATOMIC_RELEASE

Release-операция. Публикует все операции чтения и записи, выполненные до неё,
для потока, который потом выполнит соответствующий acquire.

Не позволяет предыдущим операциям чтения и записи быть переупорядоченными
после release-операции.

__ATOMIC_ACQ_REL

Комбинация acquire и release. Обычно используется для read-modify-write операций:
exchange, compare_exchange, fetch_add и т.д. Эти операции в базовом шаблоне реализованы не в полном объеме (пока что).

__ATOMIC_SEQ_CST Самая строгая последовательно согласованная модель памяти. Она используется по умолчанию.

В моем коде std::memory_order реализован именно через эти константы:

enum memory_order
{
    memory_order_relaxed = __ATOMIC_RELAXED,
    memory_order_acquire = __ATOMIC_ACQUIRE,
    memory_order_release = __ATOMIC_RELEASE,
    memory_order_acq_rel = __ATOMIC_ACQ_REL,
    memory_order_seq_cst = __ATOMIC_SEQ_CST
};

memory_order_consume игнорируется умышленно так как практически не используется (если верить книге Райнера Гримма) и будет удален в С++ 26.

Builtin функции следующие:

// Атомарно сохраняет значение val в *ptr следуя модели памяти mem_order
void __atomic_store (type *ptr, type *val, int memorder)
// Атомарно загружает значение ptr в ret ледуя модели памяти mem_order
void __atomic_load (type *ptr, type *ret, int memorder)
// Атомарно заменяет значение ptr на val возвращая старое значение в ret
void __atomic_exchange (type *ptr, type *val, type *ret, int memorder)
// Что называется CAS. Атомарно сравнивает значение ptr с exptected и если они равны
// то атомарно присваивает ptr значение desired используя success_memorder в случае
// совпадения значений exptected и ptr, и failure_memorder для загрузки если CAS
// не прошел.
bool __atomic_compare_exchange (type *ptr, type *expected, type *desired, 
                                bool weak, int success_memorder, int failure_memorder)
// Проверяет можно ли реализовать вышеуказанные операции без блокировок, возвращает true
// если да
bool __atomic_is_lock_free (size_t size, void *ptr)

В документации написано:
The ‘__atomic’ builtins can be used with any integral scalar or pointer type that is 1, 2, 4, or 8 bytes in length. 16-byte integral types are also allowed if ‘__int128’ (see 128-bit Integers) is supported by the architecture.
Что означает что эти функции могут быть использованы для любых литералов или целых типов размером 1,2,4 или 8 байт включая указатели, что очень хорошо подходит для реализации общего шаблона std::atomic. Для таких типов компилятор обычно генерирует встроенные атомарные инструкции. Что означает что функция

bool __atomic_is_lock_free (size_t size, void *ptr)

должна возвращать true для них.

Я умышленно не использовал аналоги с постфиксом _n такие как например:

void __atomic_store_n (type *ptr, type val, int memorder)

которые принимают type по значению потому что пишу общий шаблон не только для скаляров. Так же в документации написано:

The four non-arithmetic functions (load, store, exchange, and compare_exchange) all have a generic version as well. This generic version works on any data type. It uses the lock-free built-in function if the specific data type size makes that possible; otherwise, an external call is left to be resolved at run time. This external call is the same format with the addition of a ‘size_t’ parameter inserted as the first parameter indicating the size of the object being pointed to. All objects must be the same size.

Что означает, что для типов перечисленных выше компилятор сгенерирует lock-free вызовы, иначе может быть вызвана внешняя функция с параметром size_t. В любом случае общий шаблон должен как то разрешать работу с другими тривиально копируемыми типами хотя бы в теории.

Вот и код:

__BEGIN_STD_NAMESPACE

// Константа рекомендуемая для выравнивания типов если мы хотим что бы они
// 100% оказались в разных линиях кеша
inline constexpr size_t hardware_destructive_interference_size = __GCC_DESTRUCTIVE_SIZE;
// Константа напротив рекомендует хранить тип выровненный по границе значения этой
// константы в одной линейке кеша
inline constexpr size_t hardware_constructive_interference_size = __GCC_CONSTRUCTIVE_SIZE;

// Само собой берем выше перечисленные константы из компилятора, libstdc++ gcc делает
// тоже самое, компилятор собранный для конкретной платформы знает эти значения
// давайте просто поверим ему :-)

// Все это определено тут что бы скрыть компилятрно специфичные вещи в одном
// заголовочном файле.

enum memory_order
{
    // как описано выше
    memory_order_relaxed = __ATOMIC_RELAXED,
    memory_order_acquire = __ATOMIC_ACQUIRE,
    memory_order_release = __ATOMIC_RELEASE,
    memory_order_acq_rel = __ATOMIC_ACQ_REL,
    memory_order_seq_cst = __ATOMIC_SEQ_CST
};

namespace detail
{

static memory_order __cas_failure_order(memory_order order) noexcept
{
    switch (order) {
        case memory_order_relaxed:
            return memory_order_relaxed;

        case memory_order_acquire:
            return memory_order_acquire;

        case memory_order_release:
            return memory_order_relaxed;

        case memory_order_acq_rel:
            return memory_order_acquire;

        case memory_order_seq_cst:
            return memory_order_seq_cst;
    }

    __STD_NAMESPACE::abort();
}

} // namespace detail

template<typename _Type>
class atomic
{
public:
  // атомики не копируются
    atomic(const atomic &) = delete;
    atomic &operator=(const atomic &) = delete;
    atomic &operator=(const atomic &) volatile = delete;

    atomic() = default;
    atomic(_Type __v)
        : _M_value(__v)
    {}

    _Type operator=(_Type __desired) noexcept
    {
        __atomic_store(&_M_value, &__desired, memory_order::memory_order_seq_cst);
        return __desired;
    }

    _Type operator=(_Type __desired) volatile noexcept
    {
        __atomic_store(&_M_value, &__desired, memory_order::memory_order_seq_cst);
        return __desired;
    }

    bool is_lock_free() const noexcept
    {
        return __atomic_is_lock_free(sizeof(_Type), nullptr);
    }

    bool is_lock_free() const volatile noexcept
    {
        return __atomic_is_lock_free(sizeof(_Type), nullptr);
    }

    void store(_Type __desired, __STD_NAMESPACE::memory_order __order =
    __STD_NAMESPACE::memory_order_seq_cst) noexcept
    {
        __atomic_store(&_M_value, &__desired, __order);
    }

    void store(_Type __desired, __STD_NAMESPACE::memory_order __order =
    __STD_NAMESPACE::memory_order_seq_cst) volatile noexcept
    {
        __atomic_store(&_M_value, &__desired, __order);
    }

    _Type load(__STD_NAMESPACE::memory_order __order
    = __STD_NAMESPACE::memory_order_seq_cst) const noexcept
    {
        _Type ret;
        __atomic_load(&_M_value, &ret, __order);
        return ret;
    }

    _Type load(__STD_NAMESPACE::memory_order __order
    = __STD_NAMESPACE::memory_order_seq_cst) const volatile noexcept
    {
        _Type ret;
        __atomic_load(&_M_value, &ret, __order);
        return ret;
    }

    operator _Type() const noexcept
    {
        _Type ret;
        __atomic_load(&_M_value, &ret, memory_order::memory_order_seq_cst);
        return ret;
    }

    operator _Type() const volatile noexcept
    {
        _Type ret;
        __atomic_load(&_M_value, &ret, memory_order::memory_order_seq_cst);
        return ret;
    }

    _Type exchange(_Type __desired, __STD_NAMESPACE::memory_order __order =
    __STD_NAMESPACE::memory_order_seq_cst) noexcept
    {
        _Type ret;
        __atomic_exchange(&_M_value, &__desired, &ret, __order);
        return ret;
    }

    _Type exchange(_Type __desired, __STD_NAMESPACE::memory_order __order =
    __STD_NAMESPACE::memory_order_seq_cst) volatile noexcept
    {
        _Type ret;
        __atomic_exchange(&_M_value, &__desired, &ret, __order);
        return ret;
    }

    bool compare_exchange_weak(_Type &expected, _Type __desired,
                               __STD_NAMESPACE::memory_order __success,
                               __STD_NAMESPACE::memory_order __failure) noexcept
    {
        return __atomic_compare_exchange(&_M_value, &expected, &__desired, true, __success, __failure);
    }

    bool compare_exchange_weak(_Type &expected, _Type __desired,
                               __STD_NAMESPACE::memory_order __success,
                               __STD_NAMESPACE::memory_order __failure) volatile noexcept
    {
        return __atomic_compare_exchange(&_M_value, &expected, &__desired, true, __success, __failure);
    }

    bool compare_exchange_weak(_Type &expected, _Type __desired,
                               __STD_NAMESPACE::memory_order __order =
                               __STD_NAMESPACE::memory_order_seq_cst) noexcept
    {
        return __atomic_compare_exchange(&_M_value,
                                         &expected,
                                         &__desired,
                                         true,
                                         __order,
                                         detail::__cas_failure_order(__order));
    }

    bool compare_exchange_weak(_Type &expected, _Type __desired,
                               __STD_NAMESPACE::memory_order __order =
                               __STD_NAMESPACE::memory_order_seq_cst) volatile noexcept
    {
        return __atomic_compare_exchange(&_M_value,
                                         &expected,
                                         &__desired,
                                         true,
                                         __order,
                                         detail::__cas_failure_order(__order));
    }

    bool compare_exchange_strong(_Type &expected, _Type __desired,
                                 __STD_NAMESPACE::memory_order __success,
                                 __STD_NAMESPACE::memory_order __failure) noexcept
    {
        return __atomic_compare_exchange(&_M_value, &expected, &__desired, false, __success, __failure);
    }

    bool compare_exchange_strong(_Type &expected, _Type __desired,
                                 __STD_NAMESPACE::memory_order __success,
                                 __STD_NAMESPACE::memory_order __failure) volatile noexcept
    {
        return __atomic_compare_exchange(&_M_value, &expected, &__desired, false, __success, __failure);
    }

    bool compare_exchange_strong(_Type &expected, _Type __desired,
                                 __STD_NAMESPACE::memory_order __order =
                                 __STD_NAMESPACE::memory_order_seq_cst) noexcept
    {
        return __atomic_compare_exchange(&_M_value,
                                         &expected,
                                         &__desired,
                                         false,
                                         __order,
                                         detail::__cas_failure_order(__order));
    }

    bool compare_exchange_strong
        (_Type &expected, _Type __desired,
         __STD_NAMESPACE::memory_order __order = __STD_NAMESPACE::memory_order_seq_cst) volatile noexcept
    {
        return __atomic_compare_exchange(&_M_value,
                                         &expected,
                                         &__desired,
                                         false,
                                         __order,
                                         detail::__cas_failure_order(__order));
    }
private:
    _Type _M_value{};
};

__END_STD_NAMESPACE

Зачем CAS две модели памяти?

CAS состоит из двух операций: чтение и запись. Вот тут как раз и может быть использована модель памяти memory_order_acq_rel. Что означает memory_order_acquire для чтения и если все успешно memory_order_release для записи, но если сравнение вернуло false, то никакой записи не происходит.

Вот тут мы приходим к функции

static memory_order __cas_failure_order(memory_order order) noexcept
{
    switch (order) {
        case memory_order_release:
            return memory_order_relaxed;

        case memory_order_acq_rel:
            return memory_order_acquire;

        default:
            return order;
    }
}

Вот цитата из документации к функции __atomic_compare_exchange_n (функция без постфикса_n ссылается на нее):

If desired is written into *ptr then true is returned and memory is affected according to the memory order specified by success_memorder. There are no restrictions on what memory order can be used here.

Otherwise, false is returned and memory is affected according to failure_memorder. This memory order cannot be __ATOMIC_RELEASE nor __ATOMIC_ACQ_REL. It also cannot be a stronger order than that specified by success_memorder.

Что означает буквально следующее:

если desired записан в *ptr тогда функция возвращает true и операции с памятью выполняются в соответствии с моделью памяти success_memorder. Иначе возвращается false и операции с памятью выполняются в соответствии с моделью памяти failure_memorder при чем эта модель не может быть сильнее чем success_memorder и не может быть memorder_release или memorder_acq_rel от сюда и функция.

Ну и зачем же мне такой атомик? Для реализации спинлока.

__BEGIN_STD_NAMESPACE

template<typename _Lock>
class lock_guard final
{
public:
    lock_guard(const lock_guard &) = delete;
    lock_guard &operator=
        (const lock_guard &) = delete;

    lock_guard(_Lock &__lock)
        : _M_lock(__lock)
    {
        _M_lock.lock();
    }

    ~lock_guard()
    {
        _M_lock.unlock();
    }
private:
    _Lock &_M_lock;
};

__END_STD_NAMESPACE

namespace dux
{

static constexpr int kFree = 0;

static constexpr int kLocked = 1;

class spin_lock final
{
public:
    spin_lock() = default;
    spin_lock(const spin_lock &) = delete;
    spin_lock &operator=(const spin_lock &) = delete;

    bool try_lock()
    {
        int expected = kFree;
        return _M_value.compare_exchange_strong(expected, kLocked, __STD_NAMESPACE::memory_order_acquire);
    }

    void lock()
    {
        for (;;) {
            while (_M_value.load(__STD_NAMESPACE::memory_order_relaxed) == kLocked) {
                cpu_relax();
            }

            int expected = kFree;

            if (_M_value.compare_exchange_strong(expected, kLocked, __STD_NAMESPACE::memory_order_acquire)) {
                return;
            }

            cpu_relax();
        }
    }

    void unlock()
    {
        _M_value.store(kFree, __STD_NAMESPACE::memory_order_release);
    }
private:
#ifndef OSDEV_DISABLE_SPINLOCK_ALIGNMENT
    alignas(__STD_NAMESPACE::hardware_destructive_interference_size)
#endif
    __STD_NAMESPACE::atomic<int> _M_value = kFree;
};
} // namespace dux

Вот теперь обсудим код. Я расскажу что и зачем, возможно кто то в комментариях меня поправит :-) Эффективно использовать примитивы синхронизации != уметь хорошо их писать. Большинство программистов используют теоретические знания из книг не вникая что под капотом. Начнем с выравнивания. Оно полезно когда разные потоки работают с разными спинлоками. Нужно убедиться что там нет false sharing. Вот бенчмарк:

#include <benchmark/benchmark.h>

#include <cstddef>
#include <cstdint>
#include <thread>

#include "spin_lock.h"

namespace
{

static int max_threads()
{
    const auto n = std::thread::hardware_concurrency();
    return n == 0 ? 8 : static_cast<int>(n);
}

struct padded_counter
{
#ifndef DISABLE_SPINLOCK_ALIGNMENT
    alignas(std::hardware_destructive_interference_size)
#endif
    std::uint64_t value = 0;
};

dux::spin_lock g_lock;
std::uint64_t g_shared_val = 0;

dux::spin_lock g_locks[64];
padded_counter g_counters[64];

static void BM_spin_lock_lock_unlock(benchmark::State &state)
{
    for (auto _ : state) {
        g_lock.lock();
        benchmark::ClobberMemory();
        g_lock.unlock();
    }
}

BENCHMARK(BM_spin_lock_lock_unlock)
->Threads(1)
->Threads(2)
->Threads(4)
->Threads(8)
->Threads(16)
->UseRealTime();

static void BM_spin_lock_increment(benchmark::State &state)
{
    for (auto _ : state) {
        g_lock.lock();

        benchmark::DoNotOptimize(g_shared_val);
        ++g_shared_val;
        benchmark::DoNotOptimize(g_shared_val);

        g_lock.unlock();
    }
}

BENCHMARK(BM_spin_lock_increment)
->Threads(1)
->Threads(2)
->Threads(4)
->Threads(8)
->Threads(16)
->UseRealTime();

static void BM_spin_lock_try_lock(benchmark::State &state)
{
    std::uint64_t acquired = 0;
    std::uint64_t failed = 0;

    for (auto _ : state) {
        if (g_lock.try_lock()) {
            ++acquired;
            benchmark::DoNotOptimize(acquired);
            g_lock.unlock();
        } else {
            ++failed;
            benchmark::DoNotOptimize(failed);
        }
    }

    state.counters["acquired"] = static_cast<double>(acquired);
    state.counters["failed"] = static_cast<double>(failed);
}

BENCHMARK(BM_spin_lock_try_lock)
->Threads(1)
->Threads(2)
->Threads(4)
->Threads(8)
->Threads(16)
->UseRealTime();

static void BM_spin_lock_independent_lock_unlock(benchmark::State &state)
{
    const auto index = static_cast<std::size_t>(state.thread_index());
    auto &lock = g_locks[index];

    for (auto _ : state) {
        lock.lock();
        benchmark::ClobberMemory();
        lock.unlock();
    }
}

BENCHMARK(BM_spin_lock_independent_lock_unlock)
->Threads(1)
->Threads(2)
->Threads(4)
->Threads(8)
->Threads(16)
->UseRealTime();

static void BM_spin_lock_independent_increment(benchmark::State &state)
{
    const auto index = static_cast<std::size_t>(state.thread_index());
    auto &lock = g_locks[index];
    auto &counter = g_counters[index].value;

    for (auto _ : state) {
        lock.lock();

        benchmark::DoNotOptimize(counter);
        ++counter;
        benchmark::DoNotOptimize(counter);

        lock.unlock();
    }
}

BENCHMARK(BM_spin_lock_independent_increment)
->Threads(1)
->Threads(2)
->Threads(4)
->Threads(8)
->Threads(16)
->UseRealTime();

} // namespace

Вот вывод:

dmitry@DESKTOP-P6O5NDM:/mnt/d/osdev/osdev-libstdc/build$ benchmarks/spin_lock_unaligned_bench
2026-06-28T03:46:36+03:00
Running benchmarks/spin_lock_unaligned_bench
Run on (8 X 2592 MHz CPU s)
CPU Caches:
  L1 Data 32 KiB (x4)
  L1 Instruction 32 KiB (x4)
  L2 Unified 256 KiB (x4)
  L3 Unified 6144 KiB (x1)
Load Average: 0.34, 0.33, 0.37
----------------------------------------------------------------------------------------------------
Benchmark                                                          Time             CPU   Iterations
----------------------------------------------------------------------------------------------------
BM_spin_lock_lock_unlock/real_time/threads:1                    10.3 ns         10.3 ns     64582112
BM_spin_lock_lock_unlock/real_time/threads:2                    60.3 ns         60.3 ns     17700950
BM_spin_lock_lock_unlock/real_time/threads:4                     207 ns          207 ns      3742600
BM_spin_lock_lock_unlock/real_time/threads:8                     481 ns          480 ns      1585560
BM_spin_lock_lock_unlock/real_time/threads:16                   1401 ns          838 ns      2109376
BM_spin_lock_increment/real_time/threads:1                      10.9 ns         10.8 ns     63073209
BM_spin_lock_increment/real_time/threads:2                      64.0 ns         64.0 ns     18999582
BM_spin_lock_increment/real_time/threads:4                       338 ns          338 ns      2112388
BM_spin_lock_increment/real_time/threads:8                       976 ns          976 ns       803088
BM_spin_lock_increment/real_time/threads:16                     1716 ns         1058 ns       399536
BM_spin_lock_try_lock/real_time/threads:1                       10.6 ns         10.6 ns     63413468 acquired=63.4135M failed=0
BM_spin_lock_try_lock/real_time/threads:2                       38.4 ns         38.4 ns     13378522 acquired=7.33797M failed=6.04055M
BM_spin_lock_try_lock/real_time/threads:4                       86.6 ns         86.6 ns      7722064 acquired=2.38821M failed=5.33386M
BM_spin_lock_try_lock/real_time/threads:8                        174 ns          174 ns      3800696 acquired=759.232k failed=3.04146M
BM_spin_lock_try_lock/real_time/threads:16                       271 ns          160 ns      2954560 acquired=355.828k failed=2.59873M
BM_spin_lock_independent_lock_unlock/real_time/threads:1        11.1 ns         11.1 ns     62118911
BM_spin_lock_independent_lock_unlock/real_time/threads:2        12.0 ns         12.0 ns     54042118
BM_spin_lock_independent_lock_unlock/real_time/threads:4        13.0 ns         13.0 ns     40000000
BM_spin_lock_independent_lock_unlock/real_time/threads:8        15.3 ns         15.3 ns     46448664
BM_spin_lock_independent_lock_unlock/real_time/threads:16       22.9 ns         14.1 ns     31888608
BM_spin_lock_independent_increment/real_time/threads:1          7.55 ns         7.55 ns     95136873
BM_spin_lock_independent_increment/real_time/threads:2          37.9 ns         37.9 ns     19401330
BM_spin_lock_independent_increment/real_time/threads:4           111 ns          111 ns      7266824
BM_spin_lock_independent_increment/real_time/threads:8           156 ns          156 ns      4608392
BM_spin_lock_independent_increment/real_time/threads:16          202 ns          121 ns      3778864
dmitry@DESKTOP-P6O5NDM:/mnt/d/osdev/osdev-libstdc/build$ benchmarks/spin_lock_aligned_bench
2026-06-28T03:46:51+03:00
Running benchmarks/spin_lock_aligned_bench
Run on (8 X 2592 MHz CPU s)
CPU Caches:
  L1 Data 32 KiB (x4)
  L1 Instruction 32 KiB (x4)
  L2 Unified 256 KiB (x4)
  L3 Unified 6144 KiB (x1)
Load Average: 0.48, 0.36, 0.38
----------------------------------------------------------------------------------------------------
Benchmark                                                          Time             CPU   Iterations
----------------------------------------------------------------------------------------------------
BM_spin_lock_lock_unlock/real_time/threads:1                    10.6 ns         10.6 ns     66394512
BM_spin_lock_lock_unlock/real_time/threads:2                    70.2 ns         70.2 ns     18677182
BM_spin_lock_lock_unlock/real_time/threads:4                     204 ns          204 ns      4770612
BM_spin_lock_lock_unlock/real_time/threads:8                     376 ns          376 ns      1793640
BM_spin_lock_lock_unlock/real_time/threads:16                   1105 ns          641 ns      1086608
BM_spin_lock_increment/real_time/threads:1                      11.3 ns         11.3 ns     62477240
BM_spin_lock_increment/real_time/threads:2                      88.7 ns         88.7 ns      8700034
BM_spin_lock_increment/real_time/threads:4                       261 ns          261 ns      2785552
BM_spin_lock_increment/real_time/threads:8                       939 ns          938 ns       808024
BM_spin_lock_increment/real_time/threads:16                     2206 ns         1242 ns       339232
BM_spin_lock_try_lock/real_time/threads:1                       10.6 ns         10.6 ns     65253768 acquired=65.2538M failed=0
BM_spin_lock_try_lock/real_time/threads:2                       37.1 ns         37.1 ns     24611966 acquired=12.8617M failed=11.7503M
BM_spin_lock_try_lock/real_time/threads:4                       77.7 ns         77.7 ns      7477224 acquired=2.39673M failed=5.0805M
BM_spin_lock_try_lock/real_time/threads:8                        165 ns          165 ns      4384976 acquired=754.444k failed=3.63053M
BM_spin_lock_try_lock/real_time/threads:16                       254 ns          148 ns      3188912 acquired=402.998k failed=2.78591M
BM_spin_lock_independent_lock_unlock/real_time/threads:1        10.6 ns         10.6 ns     71575886
BM_spin_lock_independent_lock_unlock/real_time/threads:2        12.1 ns         12.1 ns     60238786
BM_spin_lock_independent_lock_unlock/real_time/threads:4        13.1 ns         13.1 ns     40000000
BM_spin_lock_independent_lock_unlock/real_time/threads:8        14.9 ns         14.9 ns     46986640
BM_spin_lock_independent_lock_unlock/real_time/threads:16       22.4 ns         14.1 ns     30550288
BM_spin_lock_independent_increment/real_time/threads:1          12.2 ns         12.2 ns     57258680
BM_spin_lock_independent_increment/real_time/threads:2          13.0 ns         13.0 ns     53044384
BM_spin_lock_independent_increment/real_time/threads:4          13.7 ns         13.7 ns     40000000
BM_spin_lock_independent_increment/real_time/threads:8          14.8 ns         14.8 ns     49200832
BM_spin_lock_independent_increment/real_time/threads:16         22.2 ns         13.9 ns     32020000

Мы видим что как я и сказал выше секция BM_spin_lock_independent работает быстрее с вырваниванием. Конкретно в osdev-libstdc можно использовать макрос OSDEV_DISABLE_SPINLOCK_ALIGNMENT что бы его отключить. Идем дальше.

Логика захвата TTAS (test-test-and-set), а не TAS (test-and-set) как в классическом спинлоке реализуемом через std::atomic_flag. Буквально это означает что при попытке захватить лок поток сначала проверяет свободен ли он выполняя операцию load, что не требует переключения кеш линии в состояние modified. Каждый раз в цикле ожидания.

Exchange осуществляется только если лок свободен что снижает нагрузку на кеш. exchage это одна атомарная операция поэтому поток всегда пытается получить право на запись кеш линии не зависимо от того совпадает текущее значение с желаемым или нет. Если бы при выполнении exhange сначала выполнялось чтение и принималось бы решение нужно право на запись или нет, атомарность операции была бы нарушена. Т.е. архитектурно это операция единая атомарная read-modify-write когда ЦПУ не может сначала выполнить чтение и потом решать нужна ли запись. Это архитектурная необходимость. Что означает что другой ЦПУ мог бы изменить значение между чтением и принятием решения нужно ли право на запись.

Вот TTAS графически:

Вот бенчмарк

#include <benchmark/benchmark.h>

#include "../include/atomic.h"
#include <asm/cpu.h>
#include <cstdint>
#include <thread>

namespace
{

class tas_spin_lock
{
public:
    static constexpr int kFree = 0;
    static constexpr int kLocked = 1;

    bool try_lock()
    {
        return _M_value.exchange(kLocked, __STD_NAMESPACE::memory_order_acquire) == kFree;
    }

    void lock()
    {
        while (_M_value.exchange(kLocked, __STD_NAMESPACE::memory_order_acquire) != kFree) {
            cpu_relax();
        }
    }

    void unlock()
    {
        _M_value.store(kFree, __STD_NAMESPACE::memory_order_release);
    }

private:
    alignas(__STD_NAMESPACE::hardware_destructive_interference_size)
    __STD_NAMESPACE::atomic<int> _M_value = kFree;
};

class ttas_spin_lock
{
public:
    static constexpr int kFree = 0;
    static constexpr int kLocked = 1;

    bool try_lock()
    {
        return _M_value.exchange(kLocked, __STD_NAMESPACE::memory_order_acquire) == kFree;
    }

    void lock()
    {
        for (;;) {
            while (_M_value.load(__STD_NAMESPACE::memory_order_relaxed) == kLocked) {
                cpu_relax();
            }

            if (_M_value.exchange(kLocked, __STD_NAMESPACE::memory_order_acquire) == kFree) {
                return;
            }
        }
    }

    void unlock()
    {
        _M_value.store(kFree, __STD_NAMESPACE::memory_order_release);
    }

private:
    alignas(__STD_NAMESPACE::hardware_destructive_interference_size)
    __STD_NAMESPACE::atomic<int> _M_value = kFree;
};

template <typename Lock>
struct bench_data
{
    Lock lock;
    std::uint64_t shared_val = 0;
};

bench_data<tas_spin_lock> g_tas_data;
bench_data<ttas_spin_lock> g_ttas_data;

template <typename Lock>
static void BM_lock_unlock(benchmark::State &state, bench_data<Lock> &data)
{
    for (auto _ : state) {
        data.lock.lock();
        benchmark::ClobberMemory();
        data.lock.unlock();
    }
}

template <typename Lock>
static void BM_increment(benchmark::State &state, bench_data<Lock> &data)
{
    for (auto _ : state) {
        data.lock.lock();

        benchmark::DoNotOptimize(data.shared_val);
        ++data.shared_val;
        benchmark::DoNotOptimize(data.shared_val);

        data.lock.unlock();
    }
}

static void BM_TAS_lock_unlock(benchmark::State &state)
{
    BM_lock_unlock(state, g_tas_data);
}

BENCHMARK(BM_TAS_lock_unlock)
->Threads(1)
->Threads(2)
->Threads(4)
->Threads(8)
->Threads(16)
->UseRealTime();

static void BM_TTAS_lock_unlock(benchmark::State &state)
{
    BM_lock_unlock(state, g_ttas_data);
}

BENCHMARK(BM_TTAS_lock_unlock)
->Threads(1)
->Threads(2)
->Threads(4)
->Threads(8)
->Threads(16)
->UseRealTime();

static void BM_TAS_increment(benchmark::State &state)
{
    BM_increment(state, g_tas_data);
}

BENCHMARK(BM_TAS_increment)
->Threads(1)
->Threads(2)
->Threads(4)
->Threads(8)
->Threads(16)
->UseRealTime();

static void BM_TTAS_increment(benchmark::State &state)
{
    BM_increment(state, g_ttas_data);
}

BENCHMARK(BM_TTAS_increment)
->Threads(1)
->Threads(2)
->Threads(4)
->Threads(8)
->Threads(16)
->UseRealTime();

} // namespace

Вот вывод:

dmitry@DESKTOP-P6O5NDM:/mnt/d/osdev/osdev-libstdc/build$ benchmarks/spin_ttas_vs_tas_bench
2026-06-28T05:00:27+03:00
Running benchmarks/spin_ttas_vs_tas_bench
Run on (8 X 2592 MHz CPU s)
CPU Caches:
  L1 Data 32 KiB (x4)
  L1 Instruction 32 KiB (x4)
  L2 Unified 256 KiB (x4)
  L3 Unified 6144 KiB (x1)
Load Average: 0.05, 0.01, 0.00
-----------------------------------------------------------------------------------
Benchmark                                         Time             CPU   Iterations
-----------------------------------------------------------------------------------
BM_TAS_lock_unlock/real_time/threads:1         10.8 ns         10.8 ns     63718850
BM_TAS_lock_unlock/real_time/threads:2         62.1 ns         62.1 ns     12398532
BM_TAS_lock_unlock/real_time/threads:4          317 ns          317 ns      3311780
BM_TAS_lock_unlock/real_time/threads:8          809 ns          809 ns      1074088
BM_TAS_lock_unlock/real_time/threads:16        2821 ns         1567 ns       274768
BM_TTAS_lock_unlock/real_time/threads:1        10.7 ns         10.7 ns     68831786
BM_TTAS_lock_unlock/real_time/threads:2        90.9 ns         90.9 ns      9534798
BM_TTAS_lock_unlock/real_time/threads:4         220 ns          220 ns      5248624
BM_TTAS_lock_unlock/real_time/threads:8         421 ns          389 ns      1257544
BM_TTAS_lock_unlock/real_time/threads:16       1036 ns          617 ns      2138256
BM_TAS_increment/real_time/threads:1           7.22 ns         7.22 ns     97365700
BM_TAS_increment/real_time/threads:2           79.5 ns         79.5 ns      9393780
BM_TAS_increment/real_time/threads:4            499 ns          499 ns      1944148
BM_TAS_increment/real_time/threads:8           1315 ns         1299 ns      1019816
BM_TAS_increment/real_time/threads:16          4356 ns         2699 ns       238320
BM_TTAS_increment/real_time/threads:1          9.30 ns         9.30 ns     97584095
BM_TTAS_increment/real_time/threads:2          44.4 ns         44.4 ns     16578246
BM_TTAS_increment/real_time/threads:4           320 ns          320 ns      2399060
BM_TTAS_increment/real_time/threads:8           955 ns          955 ns       741168
BM_TTAS_increment/real_time/threads:16         2874 ns         1631 ns       830592

В следующих статьях будем писать malloc, realloc, calloc, alloc_aligned, free со спин локом. Возможно будет обзор возможностей osdev-libstdc в целом. Если кому интересно это дело напишите в комментариях сделаю.

Далее реализация минимального libcppabi с потоко безопасной инициализацией локальных статических объектов new/delete. Мы реализуем магию new/delete и станет понято откуда delete[] знает размер массива.

До новых встреч!

osdev-libstdc: реализация std::atomic и spin_lock