• my old eventcount ported to Relacy...

    From Chris M. Thomasson@chris.m.thomasson.1@gmail.com to comp.lang.c++ on Sun Nov 15 15:30:49 2026
    From Newsgroup: comp.lang.c++

    I wrote about this a long time ago back in 2005. I need to find my old
    post on c.p.t. Joe mentioned the damn memory barriers, uggg. But, it
    should work with a distributed version of my futex stack I posted here yesterday. Passes tests:

    _____________________
    #pragma once

    #include <relacy/relacy.hpp>
    #include <cstdio>
    #include <cstddef>
    #include <cstdlib>
    #include <string>
    #include <vector>


    namespace ct
    {
    namespace eventcount_test
    {
    constexpr unsigned long CT_THREADS = 4;
    constexpr unsigned long CT_ITERS = 3;

    // debug
    static unsigned long g_debug_wait_calls = 0;
    static unsigned long g_debug_notify_slow = 0;


    struct eventcount
    {
    enum : unsigned long
    {
    WAITERS = 0x80000000ul,
    COUNT = 0x7FFFFFFFul
    };

    rl::atomic<unsigned long> m_ec = { 0 };

    unsigned long
    get_key()
    {
    // slow path anyway...
    unsigned long prev = m_ec.fetch_or(WAITERS,
    rl::mo_seq_cst, $);
    return prev & COUNT;
    }

    void
    wait_key(unsigned long key)
    {
    m_ec.wait(key | WAITERS, rl::mo_relaxed, $);
    ++g_debug_wait_calls;
    }

    void
    notify_all()
    {
    // GRRRRRR!!!!!
    // humm... might be ripe for async...
    // or help from the user algo state...
    unsigned long local = m_ec.load(rl::mo_seq_cst, $);

    if (local & WAITERS)
    {
    while (! m_ec.compare_exchange_strong(
    local, (local + 1) & COUNT, rl::mo_relaxed, $))
    {

    }

    m_ec.notify_all($); // grrr! from my old code.
    ++g_debug_notify_slow;
    }
    }
    };

    struct ec_mutex
    {
    rl::atomic<unsigned long> m_state = { 0 };
    eventcount m_eventcount;


    // Test the eventcount version...
    void
    ec_lock()
    {
    while (m_state.exchange(1, rl::mo_acquire, $))
    {
    unsigned long key = m_eventcount.get_key();

    if (! m_state.exchange(1, rl::mo_acquire, $))
    {
    break;
    }

    m_eventcount.wait_key(key);
    }
    }

    void
    ec_unlock()
    {
    m_state.store(0, rl::mo_release, $);
    m_eventcount.notify_all();
    }
    };


    // the actual test unit...
    struct eventcount_relacy_test_v000
    : rl::test_suite<eventcount_relacy_test_v000, CT_THREADS>
    {
    ec_mutex m_mutex;

    VAR_T(unsigned long) m_state = { 0 };

    void before()
    {
    RL_ASSERT(VAR(m_state) == 0);
    }

    void after()
    {
    RL_ASSERT(VAR(m_state) == CT_THREADS * CT_ITERS);
    }

    void
    thread(
    unsigned int tidx
    ) {
    for (unsigned long i = 0; i < CT_ITERS; ++i)
    {
    m_mutex.ec_lock();

    {
    VAR(m_state) += 1;
    }

    m_mutex.ec_unlock();
    }
    }
    };
    }
    }


    namespace ct
    {
    namespace eventcount_test
    {
    namespace test
    {
    inline void
    manifest(
    rl::test_params& p
    ) {

    rl::simulate<ct::eventcount_test::eventcount_relacy_test_v000>(p);

    std::cout << "g_debug_wait_calls = " <<
    g_debug_wait_calls << "\n";
    std::cout << "g_debug_notify_slow = " <<
    g_debug_notify_slow << "\n";
    }
    }
    }
    }
    _____________________
    --- Synchronet 3.22a-Linux NewsLink 1.2