activity_channel.hpp

Go to the documentation of this file.

#pragma once

 
#include <array>
#include <atomic>
#include <cstddef>
#include <cstdint>
#include <memory>
 
namespace pulp::runtime {

template <std::size_t LaneCount>
class ActivityChannel {
    static_assert(LaneCount > 0, "ActivityChannel must have at least one lane");
    static_assert(std::atomic<std::uint32_t>::is_always_lock_free,
                  "ActivityChannel requires lock-free 32-bit atomics");
 
public:
    using Sequence = std::uint32_t;
 
    static constexpr std::size_t lane_count() noexcept { return LaneCount; }

    void signal(std::size_t lane) noexcept {
        if (lane >= LaneCount) return;
        sequences_[lane].fetch_add(1, std::memory_order_relaxed);
    }

    Sequence sequence(std::size_t lane) const noexcept {
        if (lane >= LaneCount) return 0;
        return sequences_[lane].load(std::memory_order_relaxed);
    }

    bool consume(std::size_t lane, Sequence& cursor) const noexcept {
        return consume_count(lane, cursor) != 0;
    }

    Sequence consume_count(std::size_t lane, Sequence& cursor) const noexcept {
        if (lane >= LaneCount) return 0;
        const Sequence current = sequence(lane);
        const Sequence count = current - cursor;
        cursor = current;
        return count;
    }
 
private:
    std::array<std::atomic<Sequence>, LaneCount> sequences_{};
};
 
template <std::size_t LaneCount>
using SharedActivityChannel = std::shared_ptr<ActivityChannel<LaneCount>>;
 
template <std::size_t LaneCount>
SharedActivityChannel<LaneCount> make_activity_channel() {
    return std::make_shared<ActivityChannel<LaneCount>>();
}
 
} // namespace pulp::runtime