#ifndef spinlock_h
#define spinlock_h

#include <atomic>
#include <chrono>
#include <iostream>
#include <mutex>
#include <optional>
#include <stack>
#include <thread>

using namespace std::literals;

class spinlock
{
public:
    void lock()
    {
        auto backoff = 1us;
        while (flag.test(std::memory_order_relaxed) ||
               flag.test_and_set(std::memory_order_acquire))
            std::this_thread::sleep_for(backoff *= 2);
    }

    void unlock()
    {
        flag.clear(std::memory_order_release);
    }

private:
    std::atomic_flag flag;
};

template<typename T> class stack
{
public:
    void push(T t)
    {
        std::lock_guard lock(s);
        container.push(t);
    }

    std::optional<T> pop()
    {
        std::lock_guard lock(s);
        if (!container.empty())
        {
            T data = container.top();
            container.pop();
            return std::optional<T>(data);
        }
        else
        {
            return std::nullopt;
        }
    }

private:
    spinlock s;
    std::stack<T> container;
};

#endif // spinlock_h

// #include <valgrind/helgrind.h>

// class spinlock
// {
// public:
//     void lock()
//     {
//         auto backoff = 1us;
//         while (flag.test(std::memory_order_relaxed) ||
//                flag.test_and_set(std::memory_order_acquire))
//             std::this_thread::sleep_for(backoff *= 2);
//         ANNOTATE_HAPPENS_AFTER(&flag);
//     }

//     void unlock()
//     {
//         ANNOTATE_HAPPENS_BEFORE(&flag);
//         flag.clear(std::memory_order_release);
//     }

// private:
//     std::atomic_flag flag;
// };