LamportQueueTest.cpp

#include "LamportQueue2.hpp"
#include "LamportQueue3.hpp"
#include "LamportQueue4.hpp"
#include "LamportQueue5.hpp"
#include "LamportQueue6.hpp"
#include "LamportQueue7.hpp"
#include "LamportQueue8.hpp"
#include "LamportQueue9.hpp"
#include "BenchmarkSupport.hpp"
#include "Platform.hpp"
#include <new>

template<typename type>
static void LamportQueueTest(benchmark::State& state) {
    static std::atomic<type*> queue = nullptr;

    if (state.thread_index() == 0) {
        queue.store(new type);
    } else {
        while (queue.load() == nullptr) {}
    }

    type& q = *queue;
    if (state.thread_index() == 0) {
        PREPARE_THREAD(Thread1Affinity);
        for (auto _ : state) {
            int counter = 10000;
            while (counter > 0) {
                counter -= int(q.Enqueue());
            }
        }
    } else if (state.thread_index() == 1) {
        PREPARE_THREAD(Thread2Affinity);
        for (auto _ : state) {
            int counter = 10000;
            while (counter > 0) {
                counter -= int(q.Dequeue([](typename type::value_type&&) {}));
            }
        }

        delete queue.load();
        queue.store(nullptr);
    }
    state.SetItemsProcessed(state.iterations() * 10000);
    state.SetBytesProcessed(state.iterations() * 10000 * sizeof(typename type::value_type));
}

template<typename type>
static void LamportQueueLatencyTest(benchmark::State& state) {
    static std::atomic<type*> queue1 = nullptr;
    static std::atomic<type*> queue2 = nullptr;

    if (state.thread_index() == 0) {
        queue1.store(new type);
        queue2.store(new type);
    } else {
        while (queue1.load() == nullptr) {}
        while (queue2.load() == nullptr) {}
    }

    type& q1 = *queue1;
    type& q2 = *queue2;

    if (state.thread_index() == 0) {
        PREPARE_THREAD(Thread1Affinity);
        for (auto _ : state) {
            int counter = 10000;
            while (counter > 0) {
                q1.Enqueue();
                while (q2.Dequeue([](typename type::value_type&&) {}) != 1) {}
                counter -= 1;
            }
        }

        delete queue1.load();
        delete queue2.load();
        queue1.store(nullptr);
        queue2.store(nullptr);
    } else if (state.thread_index() == 1) {
        PREPARE_THREAD(Thread2Affinity);
        for (auto _ : state) {
            int counter = 10000;
            while (counter > 0) {
                counter -= int(q1.Dequeue(
                    [&q2](typename type::value_type&& e) {
                        q2.Enqueue(std::move(e));
                    }
                ));
            }
        }
    }
}

QUEUE_BENCH(LamportQueueTest, LamportQueue2);
QUEUE_BENCH(LamportQueueTest, LamportQueue3);
QUEUE_BENCH(LamportQueueTest, LamportQueue4);
QUEUE_BENCH(LamportQueueTest, LamportQueue5);
QUEUE_BENCH(LamportQueueTest, LamportQueue6);
QUEUE_BENCH(LamportQueueTest, LamportQueue7);
QUEUE_BENCH(LamportQueueTest, LamportQueue8);
QUEUE_BENCH(LamportQueueTest, LamportQueue9);

QUEUE_BENCH_FOR_SIZE(LamportQueueLatencyTest, LamportQueue2, 8);
QUEUE_BENCH_FOR_SIZE(LamportQueueLatencyTest, LamportQueue3, 8);
QUEUE_BENCH_FOR_SIZE(LamportQueueLatencyTest, LamportQueue4, 8);
QUEUE_BENCH_FOR_SIZE(LamportQueueLatencyTest, LamportQueue5, 8);
QUEUE_BENCH_FOR_SIZE(LamportQueueLatencyTest, LamportQueue6, 8);
QUEUE_BENCH_FOR_SIZE(LamportQueueLatencyTest, LamportQueue7, 8);
QUEUE_BENCH_FOR_SIZE(LamportQueueLatencyTest, LamportQueue8, 8);
QUEUE_BENCH_FOR_SIZE(LamportQueueLatencyTest, LamportQueue9, 8);