Dining Philosophers Rebooted (VS2013)

#include <chrono>
#include <mutex>
#include <random>
#include <array>
#include <vector>
#include <thread>
#include <iostream>

#ifdef SMART_POLITE

template <class L0, class L1>
void
lock(L0& l0, L1& l1)
{
    while (true)
    {
        {
            std::unique_lock<L0> u0(l0);
            if (l1.try_lock())
            {
                u0.release();
                break;
            }
        }
        std::this_thread::yield();
        {
            std::unique_lock<L1> u1(l1);
            if (l0.try_lock())
            {
                u1.release();
                break;
            }
        }
        std::this_thread::yield();
    }
}

#elif defined(SMART)

template <class L0, class L1>
void
lock(L0& l0, L1& l1)
{
    while (true)
    {
        {
            std::unique_lock<L0> u0(l0);
            if (l1.try_lock())
            {
                u0.release();
                break;
            }
        }
        {
        std::unique_lock<L1> u1(l1);
        if (l0.try_lock())
        {
            u1.release();
            break;
        }
    }
    }
}

#elif defined(PERSISTENT)

template <class L0, class L1>
void
lock(L0& l0, L1& l1)
{
    while (true)
    {
        std::unique_lock<L0> u0(l0);
        if (l1.try_lock())
        {
            u0.release();
            break;
        }
    }
}

#elif defined(ORDERED)

template <class L0>
void
lock(L0& l0, L0& l1)
{
    if (l0.mutex() < l1.mutex())
    {
        std::unique_lock<L0> u0(l0);
        l1.lock();
        u0.release();
    }
    else
    {
        std::unique_lock<L0> u1(l1);
        l0.lock();
        u1.release();
    }
}

#elif defined(STD)

template <class L0>
void
lock(L0& l0, L0& l1)
{
    std::lock(l0, l1);
}

#endif

#define constexpr const

class Philosopher
{
    std::mt19937_64 eng_{ std::random_device{}() };

    std::mutex& left_fork_;
    std::mutex& right_fork_;
    std::chrono::milliseconds eat_time_{ 0 };
    static constexpr std::chrono::seconds full_;

public:
    Philosopher(std::mutex& left, std::mutex& right);
    void dine();

private:
    void eat();
    bool flip_coin();
    std::chrono::milliseconds get_eat_duration();
};

constexpr std::chrono::seconds Philosopher::full_{ 30 };

Philosopher::Philosopher(std::mutex& left, std::mutex& right)
: left_fork_(left)
, right_fork_(right)
{}

void
Philosopher::dine()
{
    while (eat_time_ < full_)
        eat();
}

void
Philosopher::eat()
{
    using Lock = std::unique_lock<std::mutex>;
    Lock first;
    Lock second;
    if (flip_coin())
    {
        first = Lock(left_fork_, std::defer_lock);
        second = Lock(right_fork_, std::defer_lock);
    }
    else
    {
        first = Lock(right_fork_, std::defer_lock);
        second = Lock(left_fork_, std::defer_lock);
    }
    auto d = get_eat_duration();
    ::lock(first, second);
    auto end = std::chrono::steady_clock::now() + d;
    while (std::chrono::steady_clock::now() < end)
        ;
    eat_time_ += d;
}

bool
Philosopher::flip_coin()
{
    std::bernoulli_distribution d;
    return d(eng_);
}

std::chrono::milliseconds
Philosopher::get_eat_duration()
{
    std::uniform_int_distribution<> ms(1, 10);
    return std::min(std::chrono::milliseconds(ms(eng_)), full_ - eat_time_);
}

int
main()
{
#ifdef SMART_POLITE
    std::cout << "SMART_POLITE\n";
#elif defined(SMART)
    std::cout << "SMART\n";
#elif defined(PERSISTENT)
    std::cout << "PERSISTENT\n";
#elif defined(ORDERED)
    std::cout << "ORDERED\n";
#elif defined(STD)
    std::cout << "STANDARD\n";
#endif
    for (unsigned nt = 2; nt <= 32; ++nt)
    {
        std::vector<std::mutex> table(nt);
        std::vector<Philosopher> diners;
        for (unsigned i = 0; i < table.size(); ++i)
        {
            int j = i;
            int k = j < table.size() - 1 ? j + 1 : 0;
            diners.push_back(Philosopher(table[j], table[k]));
        }
        std::vector<std::thread> threads(diners.size());
        unsigned i = 0;
        auto t0 = std::chrono::high_resolution_clock::now();
        for (auto& t : threads)
        {
            t = std::thread(&Philosopher::dine, diners[i]);
            ++i;
        }
        for (auto& t : threads)
            t.join();
        auto t1 = std::chrono::high_resolution_clock::now();
        using secs = std::chrono::duration<float>;
        std::cout << "nt = " << nt << " : " << secs(t1 - t0).count() << std::endl;
    }
}