View difference between Paste ID: pY55bVQQ and CZ3xiAT4

 #include <chrono>
 #include <mutex>
 #include <random>
 #include <array>
 #include <vector>
 #include <thread>
 #include <iostream>
 
 #ifdef SMART_POLITE
 
-template <class L0, class L1>
+template <class L0, class L1> void lock(L0 &l0, L1 &l1) {
-void
+  while (true) {
-lock(L0& l0, L1& l1)
+    {
-{
+      std::unique_lock<L0> u0(l0);
-	while (true)
+      if (l1.try_lock()) {
-	{
+        u0.release();
-		{
+        break;
-			std::unique_lock<L0> u0(l0);
+      }
-			if (l1.try_lock())
+    }
-			{
+    std::this_thread::yield();
-				u0.release();
+    {
-				break;
+      std::unique_lock<L1> u1(l1);
-			}
+      if (l0.try_lock()) {
-		}
+        u1.release();
-		std::this_thread::yield();
+        break;
-		{
+      }
-			std::unique_lock<L1> u1(l1);
+    }
-			if (l0.try_lock())
+    std::this_thread::yield();
-			{
+  }
-				u1.release();
+
-				break;
+
-			}
+
-		}
+
-		std::this_thread::yield();
+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();
-template <class L0, class L1>
+        break;
-void
+      }
-lock(L0& l0, L1& l1)
+    }
-{
+    {
-	while (true)
+      std::unique_lock<L1> u1(l1);
-	{
+      if (l0.try_lock()) {
-		{
+        u1.release();
-			std::unique_lock<L0> u0(l0);
+        break;
-			if (l1.try_lock())
+      }
-			{
+    }
-				u0.release();
+  }
-				break;
+
-			}
+
-		}
+
-		{
+
-		std::unique_lock<L1> u1(l1);
+template <class L0, class L1> void lock(L0 &l0, L1 &l1) {
-		if (l0.try_lock())
+  while (true) {
-		{
+    std::unique_lock<L0> u0(l0);
-			u1.release();
+    if (l1.try_lock()) {
-			break;
+      u0.release();
-		}
+      break;
-	}
+    }
-	}
+  }
 }
 
 #elif defined(ORDERED)
 
-template <class L0, class L1>
+template <class L0> void lock(L0 &l0, L0 &l1) {
-void
+  if (l0.mutex() < l1.mutex()) {
-lock(L0& l0, L1& l1)
+    std::unique_lock<L0> u0(l0);
-{
+    l1.lock();
-	while (true)
+    u0.release();
-	{
+  } else {
-		std::unique_lock<L0> u0(l0);
+    std::unique_lock<L0> u1(l1);
-		if (l1.try_lock())
+    l0.lock();
-		{
+    u1.release();
-			u0.release();
+  }
-			break;
+
-		}
+
-	}
+
 
 template <class L0> void lock(L0 &l0, L0 &l1) { std::lock(l0, l1); }
 
 #endif
-template <class L0>
+
-void
+
-lock(L0& l0, L0& l1)
+
-{
+class Philosopher {
-	if (l0.mutex() < l1.mutex())
+  std::mt19937_64 eng_{std::random_device{}()};
-	{
+
-		std::unique_lock<L0> u0(l0);
+  std::mutex &left_fork_;
-		l1.lock();
+  std::mutex &right_fork_;
-		u0.release();
+  std::chrono::milliseconds eat_time_{0};
-	}
+  static constexpr std::chrono::seconds full_;
-	else
+
-	{
+
-		std::unique_lock<L0> u1(l1);
+  Philosopher(std::mutex &left, std::mutex &right);
-		l0.lock();
+  void dine();
-		u1.release();
+
-	}
+
   void eat();
   bool flip_coin();
   std::chrono::milliseconds get_eat_duration();
 };
-template <class L0>
+
-void
+constexpr std::chrono::seconds Philosopher::full_{30};
-lock(L0& l0, L0& l1)
+
-{
+Philosopher::Philosopher(std::mutex &left, std::mutex &right)
-	std::lock(l0, l1);
+    : left_fork_(left), right_fork_(right) {}
 
 void Philosopher::dine() {
   while (eat_time_ < full_)
     eat();
 }
 
-class Philosopher
+void Philosopher::eat() {
-{
+  using Lock = std::unique_lock<std::mutex>;
-	std::mt19937_64 eng_{ std::random_device{}() };
+  Lock first;
   Lock second;
-	std::mutex& left_fork_;
+  if (flip_coin()) {
-	std::mutex& right_fork_;
+    first = Lock(left_fork_, std::defer_lock);
-	std::chrono::milliseconds eat_time_{ 0 };
+    second = Lock(right_fork_, std::defer_lock);
-	static constexpr std::chrono::seconds full_;
+  } else {
     first = Lock(right_fork_, std::defer_lock);
     second = Lock(left_fork_, std::defer_lock);
-	Philosopher(std::mutex& left, std::mutex& right);
+  }
-	void dine();
+  auto d = get_eat_duration();
   ::lock(first, second);
   auto end = std::chrono::steady_clock::now() + d;
-	void eat();
+  while (std::chrono::steady_clock::now() < end)
-	bool flip_coin();
+    ;
-	std::chrono::milliseconds get_eat_duration();
+  eat_time_ += d;
 }
 
-constexpr std::chrono::seconds Philosopher::full_{ 30 };
+bool Philosopher::flip_coin() {
   std::bernoulli_distribution d;
-Philosopher::Philosopher(std::mutex& left, std::mutex& right)
+  return d(eng_);
-: left_fork_(left)
+
-, right_fork_(right)
+
-{}
+std::chrono::milliseconds Philosopher::get_eat_duration() {
   std::uniform_int_distribution<> ms(1, 10);
-void
+  return std::min(std::chrono::milliseconds(ms(eng_)), full_ - eat_time_);
-Philosopher::dine()
+
-{
+
-	while (eat_time_ < full_)
+int main() {
-		eat();
+
   std::cout << "SMART_POLITE\n";
 #elif defined(SMART)
-void
+  std::cout << "SMART\n";
-Philosopher::eat()
+
-{
+  std::cout << "PERSISTENT\n";
-	using Lock = std::unique_lock<std::mutex>;
+
-	Lock first;
+  std::cout << "ORDERED\n";
-	Lock second;
+
-	if (flip_coin())
+  std::cout << "STANDARD\n";
-	{
+
-		first = Lock(left_fork_, std::defer_lock);
+  for (unsigned nt = 2; nt <= 32; ++nt) {
-		second = Lock(right_fork_, std::defer_lock);
+    std::vector<std::mutex> table(nt);
-	}
+    std::vector<Philosopher> diners;
-	else
+    for (unsigned i = 0; i < table.size(); ++i) {
-	{
+      int j = i;
-		first = Lock(right_fork_, std::defer_lock);
+      int k = j < table.size() - 1 ? j + 1 : 0;
-		second = Lock(left_fork_, std::defer_lock);
+      diners.push_back(Philosopher(table[j], table[k]));
-	}
+    }
-	auto d = get_eat_duration();
+    std::vector<std::thread> threads(diners.size());
-	::lock(first, second);
+    unsigned i = 0;
-	auto end = std::chrono::steady_clock::now() + d;
+    auto t0 = std::chrono::high_resolution_clock::now();
-	while (std::chrono::steady_clock::now() < end)
+    for (auto &t : threads) {
-		;
+      t = std::thread(&Philosopher::dine, diners[i]);
-	eat_time_ += d;
+      ++i;
     }
     for (auto &t : threads)
-bool
+      t.join();
-Philosopher::flip_coin()
+    auto t1 = std::chrono::high_resolution_clock::now();
-{
+    using secs = std::chrono::duration<float>;
-	std::bernoulli_distribution d;
+    std::cout << "nt = " << nt << " : " << secs(t1 - t0).count() << std::endl;
-	return d(eng_);
+  }
 }