Université de Sherbrooke, développement du jeu vidéo, CSP

#include <thread>
#include <vector>
#include <chrono>
#include <utility>
#include <iostream>
#include <algorithm>
#include <iterator>
#include <numeric>
using namespace std;
using namespace std::chrono;

template <class F, class ... Args>
   auto test(F f, Args &&... args) {
      auto pre = high_resolution_clock::now();
      auto res = f(std::forward<Args>(args)...);
      auto post = high_resolution_clock::now();
      return pair{ res, post - pre };
   }

template <class Pred>
   unsigned long compter_si_seq(const vector<int> &v, Pred pred) {
      return count_if(begin(v), end(v), pred);
   }

template <class Pred>
unsigned long compter_si_par(int nthr, const vector<int> &v, Pred pred) {
   vector<thread> th;
   vector<unsigned long> cumul(nthr);
   const size_t block_size = size(v) / nthr;
   for (int i = 0; i < nthr - 1; ++i) {
      th.emplace_back(thread{ [pred, &cumul, i,
                               b = next(begin(v), i * block_size),
                               e = next(begin(v), (i + 1) * block_size)]() mutable {
         unsigned long somme = 0;
         for (; b != e; ++b)
            if (pred(*b))
               somme++; // cumul[i]++ pour avoir du faux-partage
         cumul[i] = somme;
      } });
   }
   auto b = next(begin(v), (nthr - 1) * block_size),
        e = end(v);
   unsigned long somme = 0;
   for (; b != e; ++b)
      if (pred(*b))
         somme++; // cumul[nthr-1]++ pour avoir du faux-partage
   cumul[nthr - 1] = somme;
   for(auto & thr : th) thr.join();
   return accumulate(begin(cumul), end(cumul), 0UL);
}

int main() {
   enum { N = 100'000'000 };
   vector<int> v(N);
   generate(begin(v), end(v), [n = -1]() mutable { return n += 2; });
   auto est_impair = [](int n) { return n % 2 != 0; };
   auto [r0, dt0] = test([&] { return compter_si_seq(v, est_impair); });
   cout << "Sequentiel :\n\t" << r0 << " impairs en "
        << duration_cast<microseconds>(dt0) << '\n';
   for (int i = 2; i != 16; ++i) {
      auto [r1, dt1] = test([&] { return compter_si_par(i, v, est_impair); });
      cout << "Parallele (" << i << " fils) :\n\t" << r1 << " impairs en "
           << duration_cast<microseconds>(dt1) << '\n';
   }
}

#include <thread>
#include <vector>
#include <chrono>
#include <utility>
#include <iostream>
#include <algorithm>
#include <iterator>
#include <cstdint>
#include <numeric>
#include <random>
#include <execution>
using namespace std;
using namespace std::chrono;

template <class F, class ... Args>
   auto test(F f, Args &&... args) {
      auto pre = high_resolution_clock::now();
      auto res = f(std::forward<Args>(args)...);
      auto post = high_resolution_clock::now();
      return pair{ res, post - pre };
   }

enum class Case : std::uint16_t {
   vide, heros, vilain, bestiole, mur
};
bool est_pas_fin(Case c) {
   return c == Case::vilain || c == Case::bestiole;
}

int main() {
   enum { N = 25'000 };
   vector<Case> carte;
   carte.resize(N *N); // lent... mais tout est vide
   cout << "Generation de la carte... " << flush;
   auto [r0, dt0] = test([&] {
      mt19937 prng{ random_device{}() };
      uniform_int_distribution<int> d100{ 1, 100 };
      uniform_int_distribution<int> d4{ 1, 4 };
      for (Case &c : carte) {
         if (d100(prng) <= 15) { // 15% de cases non-vides
            c = static_cast<Case>(d4(prng));
         }
      }
      return carte.size();
   });
   cout << r0 << " elements, completee en "
        << duration_cast<milliseconds>(dt0) << '\n';

   auto [r1, dt1] = test([&carte] {
      return count_if(begin(carte), end(carte), est_pas_fin);
   });

   cout << "Sequentiel :\n\t"
        << r1 << " pas fins (" << static_cast<double>(r1) * 100 / carte.size()
        << ") en " << duration_cast<milliseconds>(dt1) << "\n";

   auto [r2, dt2] = test([&] {
      auto nth = thread::hardware_concurrency();
      const size_t block_size = carte.size() / nth;
      vector<size_t> combien(nth); // initialisés à zéro
      vector<thread> fils;
      for (decltype(nth) i = 0; i < nth - 1; ++i) {
         fils.emplace_back([i, &combien,
                            b = next(begin(carte), i * block_size),
                            e = next(begin(carte), (i + 1) * block_size)] {
            combien[i] = count_if(b, e, est_pas_fin);
         });
      }
      combien[nth - 1] = count_if(
         next(begin(carte), (nth - 1) * block_size), end(carte), est_pas_fin
      );
      for (auto &fil : fils) fil.join();
      return accumulate(begin(combien), end(combien), size_t{});
   });

   cout << "Parallele " << thread::hardware_concurrency() << " coeurs) :\n\t"
      << r2 << " pas fins (" << static_cast<double>(r2) * 100 / carte.size()
      << ") en " << duration_cast<milliseconds>(dt2) << "\n";

   auto [r3, dt3] = test([&carte] {
      return count_if(execution::par, begin(carte), end(carte), est_pas_fin);
   });
   cout << "Algo par. " << thread::hardware_concurrency() << " coeurs) :\n\t"
      << r3 << " pas fins (" << static_cast<double>(r3) * 100 / carte.size()
      << ") en " << duration_cast<milliseconds>(dt3) << "\n";
}

#include <memory>
#include <type_traits>
#include <mutex>
#include <array>
#include <iostream>
#include <atomic>
#include <chrono>
#include <utility>
using namespace std;
using namespace std::chrono;

class file_vide {};
class file_pleine {};

namespace owning {
   namespace non_raw {
      template <class T, int N>
         class file_circulaire_concurrente {
            mutex m;
            static_assert(N > 1); // bof
            struct buffer {
               static auto type() {
                  if constexpr (sizeof(T) * N <= 8096)
                     return array<T, N>{};
                  else
                     return make_unique<T[]>(N);
               }
            };
            using buf_type = decltype(buffer::type());
            buf_type buf = buffer::type();
            int ins_pt = 0;
            int ext_pt = 0;
            static int next(int n) {
               return ++n, n == N ? 0 : n;
            }
            static int prev(int n) {
               return n == 0 ? N - 1 : n - 1;
            }
            bool full() const noexcept {
               return next(ins_pt) == ext_pt;
            }
            bool empty() const noexcept {
               return ins_pt == ext_pt;
            }
         public:
            void push(const T &obj) {
               lock_guard _{ m };
               if (full()) throw file_pleine{};
               buf[ins_pt] = obj;
               ins_pt = next(ins_pt);
            }
            void pop() {
               lock_guard _{ m };
               if (empty()) throw file_vide{};
               ext_pt = next(ext_pt);
            }
            T top() {
               lock_guard _{ m };
               if (empty()) throw file_vide{};
               return buf[ext_pt];
            }
            bool try_push(const T &obj) {
               lock_guard _{ m };
               if (full()) return false;
               buf[ins_pt] = obj;
               ins_pt = next(ins_pt);
               return true;
            }
            bool try_pop(T &obj) {
               lock_guard _{ m };
               if (empty()) return false;
               obj = buf[ext_pt];
               ext_pt = next(ext_pt);
               return true;
            }
         };
   }
   namespace raw {
      template <class T, int N>
         class file_circulaire_concurrente {
            mutex m;
            static_assert(N > 1); // bof
            struct buffer {
               static auto type() {
                  if constexpr (sizeof(T) * N <= 8096)
                     return array<char, sizeof(T) * N>{};
                  else
                     return make_unique<char[]>(sizeof(T) * N);
               }
            };
            using buf_type = decltype(buffer::type());
            auto data() {
               if constexpr (is_same_v<unique_ptr<char[]>, buf_type>)
                  return buf.get();
               else
                  return &buf[0];
            }
            alignas(T) buf_type buf = buffer::type();
            int ins_pt = 0;
            int ext_pt = 0;
            static int next(int n) {
               return ++n, n == N ? 0 : n;
            }
            static int prev(int n) {
               return n == 0 ? N - 1 : n - 1;
            }
            bool full() const noexcept {
               return next(ins_pt) == ext_pt;
            }
            bool empty() const noexcept {
               return ins_pt == ext_pt;
            }
            void *elem_addr(int n) {
               return data() + n * sizeof(T);
            }
            T &elem(int n) {
               return *static_cast<T*>(elem_addr(n));
            }
         public:
            void push(const T &obj) {
               lock_guard _{ m };
               if (full()) throw file_pleine{};
               new(elem_addr(ins_pt)) T(obj);
               ins_pt = next(ins_pt);
            }
            void pop() {
               lock_guard _{ m };
               if (empty()) throw file_vide{};
               elem(ext_pt).~T();
               ext_pt = next(ext_pt);
            }
            T top() {
               lock_guard _{ m };
               if (empty()) throw file_vide{};
               return elem(ext_pt);
            }
            bool try_push(const T &obj) {
               lock_guard _{ m };
               if (full()) return false;
               new(elem_addr(ins_pt)) T(obj);
               ins_pt = next(ins_pt);
               return true;
            }
            bool try_pop(T &obj) {
               lock_guard _{ m };
               if (empty()) return false;
               obj = elem(ext_pt);
               elem(ext_pt).~T();
               ext_pt = next(ext_pt);
               return true;
            }
            file_circulaire_concurrente(const file_circulaire_concurrente &) = delete;
            file_circulaire_concurrente&
               operator=(const file_circulaire_concurrente &) = delete;
            ~file_circulaire_concurrente() {
               for (T _; try_pop(_);)
                  ;
            }
            file_circulaire_concurrente() = default;
         };
   }
}

namespace non_owning {
   namespace non_raw {
      template <class T, int N>
      class file_circulaire_concurrente {
         mutex m;
         static_assert(N > 1); // bof
         T(&buf)[N];
         int ins_pt = 0;
         int ext_pt = 0;
         static int next(int n) {
            return ++n, n == N ? 0 : n;
         }
         static int prev(int n) {
            return n == 0 ? N - 1 : n - 1;
         }
         bool full() const noexcept {
            return next(ins_pt) == ext_pt;
         }
         bool empty() const noexcept {
            return ins_pt == ext_pt;
         }
      public:
         file_circulaire_concurrente(T (&buf)[N]) : buf{ buf } {
         }
         void push(const T &obj) {
            lock_guard _{ m };
            if (full()) throw file_pleine{};
            buf[ins_pt] = obj;
            ins_pt = next(ins_pt);
         }
         void pop() {
            lock_guard _{ m };
            if (empty()) throw file_vide{};
            ext_pt = next(ext_pt);
         }
         T top() {
            lock_guard _{ m };
            if (empty()) throw file_vide{};
            return buf[ext_pt];
         }
         bool try_push(const T &obj) {
            lock_guard _{ m };
            if (full()) return false;
            buf[ins_pt] = obj;
            ins_pt = next(ins_pt);
            return true;
         }
         bool try_pop(T &obj) {
            lock_guard _{ m };
            if (empty()) return false;
            obj = buf[ext_pt];
            ext_pt = next(ext_pt);
            return true;
         }
      };
   }
   namespace raw {
      template <class T, int N>
      class file_circulaire_concurrente {
         mutex m;
         static_assert(N > 1); // bof
         alignas(T) char (&buf)[N * sizeof(T)];
         int ins_pt = 0;
         int ext_pt = 0;
         static int next(int n) {
            return ++n, n == N ? 0 : n;
         }
         static int prev(int n) {
            return n == 0 ? N - 1 : n - 1;
         }
         bool full() const noexcept {
            return next(ins_pt) == ext_pt;
         }
         bool empty() const noexcept {
            return ins_pt == ext_pt;
         }
         void *elem_addr(int n) {
            return buf + n * sizeof(T);
         }
         T &elem(int n) {
            return *static_cast<T *>(elem_addr(n));
         }
      public:
         void push(const T &obj) {
            lock_guard _{ m };
            if (full()) throw file_pleine{};
            new(elem_addr(ins_pt)) T(obj);
            ins_pt = next(ins_pt);
         }
         void pop() {
            lock_guard _{ m };
            if (empty()) throw file_vide{};
            elem(ext_pt).~T();
            ext_pt = next(ext_pt);
         }
         T top() {
            lock_guard _{ m };
            if (empty()) throw file_vide{};
            return elem(ext_pt);
         }
         bool try_push(const T &obj) {
            lock_guard _{ m };
            if (full()) return false;
            new(elem_addr(ins_pt)) T(obj);
            ins_pt = next(ins_pt);
            return true;
         }
         bool try_pop(T &obj) {
            lock_guard _{ m };
            if (empty()) return false;
            obj = elem(ext_pt);
            elem(ext_pt).~T();
            ext_pt = next(ext_pt);
            return true;
         }
         file_circulaire_concurrente(const file_circulaire_concurrente &) = delete;
         file_circulaire_concurrente &
            operator=(const file_circulaire_concurrente &) = delete;
         ~file_circulaire_concurrente() {
            for (T _; try_pop(_);)
               ;
         }
         file_circulaire_concurrente(char(&buf)[N * sizeof(T)]) : buf{ buf } {
         }
      };
   }
}


template <class F, class ... Args>
   auto test(F f, Args &&... args) {
      auto pre = high_resolution_clock::now();
      auto res = f(std::forward<Args>(args)...);
      auto post = high_resolution_clock::now();
      return pair{ res, post - pre };
   }


int main() {
   // using owning::non_raw::file_circulaire_concurrente;
   // using owning::raw::file_circulaire_concurrente;
   // file_circulaire_concurrente<int, 10> ze_file; // par exemple
   // using non_owning::non_raw::file_circulaire_concurrente;
   // int buf[10];
   using non_owning::raw::file_circulaire_concurrente;
   alignas(int) char buf[10 * sizeof(int)];
   file_circulaire_concurrente<int, 10> ze_file(buf); // par exemple
   atomic<bool> fini{ false };
   thread producteur{ [&] {
      for (int i = 0; i != 2000;)
         if (ze_file.try_push(i + 1))
            ++i;
         else
            cout << '.' << flush;
      fini = true;
   } };
   thread consommateur{ [&] {
      for (;;)
         if (int n; ze_file.try_pop(n))
            cout << n << ' ';
         else if (fini) {
            for (int n; ze_file.try_pop(n); )
               cout << n << ' ';
            break;
         }
   } };
   producteur.join(); consommateur.join();
}

#include <utility>
class evil_whatever_cast {};

class whatever {
   void *p = nullptr;
   enum class operation {
      destroy, duplicate
   };
   template <class T> struct Mgr {
      static void *operate(operation op, void *p) {
         switch (op) {
         case operation::destroy:
            delete static_cast<T *>(p);
            return nullptr;
         case operation::duplicate:
            return p ? new T(*static_cast<T *>(p)) : nullptr;
         }
         return nullptr;
      }
   };
   void *(*mgr_fct)(operation, void *) = nullptr;
   void clear() {
      if (mgr_fct) mgr_fct(operation::destroy, p);
   }
public:
   bool empty() const noexcept {
      return mgr_fct != nullptr;
   }
   whatever() = default;
   ~whatever() {
      clear();
   }
   whatever(const whatever &other)
      : p{ other.mgr_fct ? other.mgr_fct(operation::duplicate, other.p) : nullptr },
        mgr_fct{ other.mgr_fct } {
   }
   void swap(whatever &other) {
      using std::swap;
      swap(p, other.p);
      swap(mgr_fct, other.mgr_fct);
   }
   whatever &operator=(const whatever &other) {
      whatever{ other }.swap(*this);
      return *this;
   }
   template <class T>
      whatever(T obj) : p{ new T(obj) }, mgr_fct(&Mgr<T>::operate) {
      }
   template <class T>
      whatever &operator=(T && obj) {
         auto q = new T(std::forward<T>(obj)); // for exception-safety
         clear();
         p = q;
         mgr_fct = &Mgr<T>::operate;
         return *this;
      }
   whatever(whatever &&other) noexcept {
      p = std::exchange(other.p, nullptr);
      mgr_fct = std::exchange(other.mgr_fct, nullptr);
   }
   whatever &operator=(whatever &&other) noexcept {
      clear();
      p = std::exchange(other.p, nullptr);
      mgr_fct = std::exchange(other.mgr_fct, nullptr);
   }
   template <class T>
   T unsafe_downcast() const {
      return *static_cast<T *>(p);
   }
   template <class T>
   T as() const {
      return mgr_fct == &Mgr<T>::operate ? unsafe_downcast<T>() : throw evil_whatever_cast{};
   }
};
template <class D>
D whatever_cast(const whatever &p) {
   return p.as<D>();
}

#include <vector>
#include <string>
#include <iostream>
int main() {
   using namespace std;
   vector<whatever> v;
   v.push_back(3);
   v.push_back(3.14159f);
   v.push_back("potato"s); // string
   cout << whatever_cast<float>(v[1]) << endl;
   v[1] = "yo"s;
   cout << whatever_cast<string>(v[1]) << endl;
}

#include "FacetteServer.h"
#include <iostream>
#include <string_view>
using namespace std::literals;
struct Texture {
   constexpr auto getTextureName() const noexcept {
      return "Je suis un nom de texture"sv;
   }
};
struct TextureManager {
   Texture getTexture() const noexcept {
      return {};
   }
};
struct Sound {
   constexpr auto getFileName() const noexcept {
      return "SomeSound.wav"sv;
   }
};
struct SoundManager {
   Sound getSound() const noexcept {
      return {};
   }
};
int main() {
   using namespace std;
   auto &serveur = FacetteServer::get();
   serveur.installer(TextureManager{});
   serveur.installer(SoundManager{});
   // ...
   cout << utiliser_facette<SoundManager>(serveur).getSound().getFileName() << endl;
   cout << utiliser_facette<TextureManager>(serveur).getTexture().getTextureName() << endl;
}