Inside STL: Waiting for a std::atomic to change, part 1 -- Raymond Chen

When using std::atomic<std::shared_ptr<T>>, the C++ standard defines a "change" as a modification to either the stored pointer or the control block pointer. However, since atomic wait mechanisms typically track only a single memory address, the Microsoft implementation handles this limitation by using a timeout-based polling strategy to detect changes in the control block.

Inside STL: Waiting for a std::atomic<std::shared_ptr<T>> to change, part 1

by Raymond Chen

From the article:

Like other┬ástd::atomic┬áspecializations,┬ástd::atomic<std::shared_ptr<T>>┬ásupports the┬áwait┬áand┬ánotify_*┬ámethods for waiting for the value to change and reporting that the value has changed. The definition of ΓÇ£changedΓÇ¥ in the C++ language specification is that the value has changed if┬áeither┬áthe stored pointer┬áor┬áthe control block pointer has changed. A shared pointer is implemented as a┬ápair┬áof pointers, but┬áWait­On­Address┬ácan wait on at most 8 bytes, and unix futexes can wait on only four bytes, so how does this work?┬╣

The Microsoft implementation waits for the stored pointer to change, and the┬ánotify_*┬ámethods signal the stored pointer. But wait, this fails to detect the case where the stored pointer stays the same and only the control block changes.

std::atomic<std::shared_ptr<int>> p =
    std::make_shared<int>(42);

void change_control_block()
{
    auto old = p.load();
    auto empty = std::shared_ptr<int>();

    // Replace with an indulgent shared pointer
    // with the same stored pointer.
    p.store({ empty, old.get() });
    p.notify_all();
}

void wait_for_change()
{
    auto old = p.load();
    p.wait(old);
}

View the full article