whiteoutlib 0.1.0

Parsers and writers for Blizzard model and texture formats (MDX, M2, M3, BLP, DDS, PNG).
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

// SPDX-License-Identifier: BSD-3-Clause
// Copyright (c) 2026 Fernando Sahmkow

#include "whiteout/utils/timeline_semaphore.h"

#include <atomic>
#include <condition_variable>
#include <mutex>

namespace whiteout::utils {

struct TimelineSemaphore::Impl {
    std::atomic<Value> value; ///< Current completed value
    std::atomic<Value> next;  ///< Next value to hand out via next()
    std::mutex mutex;         ///< Guards cv waits
    std::condition_variable cv;

    explicit Impl(Value initialValue) noexcept : value(initialValue), next(initialValue + 1) {}
};

TimelineSemaphore::TimelineSemaphore(Value initialValue)
    : m_impl(std::make_unique<Impl>(initialValue)) {}

TimelineSemaphore::~TimelineSemaphore() = default;

TimelineSemaphore::Value TimelineSemaphore::value() const noexcept {
    return m_impl->value.load(std::memory_order_acquire);
}

void TimelineSemaphore::signal(Value v) noexcept {
    // Advance and notify under the SAME mutex acquisition.
    {
        std::lock_guard<std::mutex> const lock(m_impl->mutex);
        Value cur = m_impl->value.load(std::memory_order_relaxed);
        while (cur < v && !m_impl->value.compare_exchange_weak(cur, v, std::memory_order_release,
                                                               std::memory_order_relaxed)) {
            /* retry with updated cur */
        }
        m_impl->cv.notify_all();
    }
}

void TimelineSemaphore::wait(Value v) {
    std::unique_lock<std::mutex> lock(m_impl->mutex);
    m_impl->cv.wait(lock, [this, v] { return m_impl->value.load(std::memory_order_acquire) >= v; });
}

TimelineSemaphore::Value TimelineSemaphore::next() noexcept {
    return m_impl->next.fetch_add(1, std::memory_order_relaxed);
}

} // namespace whiteout::utils