Class LockBoundedQueueBenchmark

examples/mpsc.cpp:162–205

};

class LockBoundedQueueBenchmark : public CppBenchmark::BenchmarkPC
{
public:
    using BenchmarkPC::BenchmarkPC;

protected:
    void Initialize(CppBenchmark::ContextPC& context) override
    {
        _queue = std::make_shared<lock_bounded_queue_t<int>>(queue_bound_size);
        _count = 1;
    }

    void Cleanup(CppBenchmark::ContextPC& context) override
    {
        _queue.reset();
    }

    void RunProducer(CppBenchmark::ContextPC& context) override
    {
        if (_count >= items_to_produce)
        {
            int value = 0;
            _queue->enqueue(value);
            context.StopProduce();
            return;
        }

        int value = _count;
        _queue->enqueue(value);
        ++_count;
    }

    void RunConsumer(CppBenchmark::ContextPC& context) override
    {
        int value = -1;
        _queue->dequeue(value);
        if (value == 0)
            context.StopConsume();
    }

private:
    std::shared_ptr<lock_bounded_queue_t<int>> _queue;
    std::atomic<int> _count;
};

BENCHMARK_CLASS(ConcurrentQueueBenchmark<moodycamel::BlockingConcurrentQueue<int>>, "moodycamel::BlockingConcurrentQueue<int>", settings)
BENCHMARK_CLASS(ConcurrentQueueBenchmark<moodycamel::ConcurrentQueue<int>>, "moodycamel::ConcurrentQueueBenchmark<int>", settings)