420KH2 – Consignes pour la PFI

#include <vector>
#include <iterator>

template <class T>
   class Mat2D {
      std::vector<T> vals;
   public:
      using size_type = int;
   private:
      size_type hau_,
                lar_;
   public:
      auto begin() {
         return std::begin(vals);
      }
      auto begin() const {
         return std::begin(vals);
      }
      auto end() {
         return std::end(vals);
      }
      auto end() const {
         return std::end(vals);
      }
      Mat2D(size_type hauteur, size_type largeur)
         : hau_{ hauteur }, lar_{ largeur }, vals(hauteur * largeur) {
      }
      auto operator[](size_type n) noexcept {
         return &vals[n * largeur()];
      }
      const auto operator[](size_type n) const noexcept {
         return &vals[n * largeur()];
      }
      size_type hauteur() const noexcept {
         return hau_;
      }
      size_type largeur() const noexcept {
         return lar_;
      }
      size_type size() const noexcept {
         return vals.size();
      }
   };
// ...

// ...
#include <utility>
#include <iterator>
#include <chrono>
#include <random>
#include <iostream>
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 };
   }
int main() {
   // auto mat = fabriquer_matrice<int>(10, 20, [n = -5]() mutable { return n++; });
   auto mat = fabriquer_matrice<short>(10, 20, [prng = mt19937{ random_device{}() },
                                                d10 = uniform_int_distribution<short>{ 1,10 }]() mutable {
      return d10(prng);
   });
   cout << mat << endl;
   auto crit = [](auto n) {
      return n % 2 == 0;
   };
   auto [r0, dt0] = test([&] { return compter_sequentiel(mat, crit); });
   auto [r1, dt1] = test([&] { return compter_parallele(begin(mat), end(mat), crit); });
   cout << "Nombre de pairs (sequentiel) : " << r0
        << " obtenu en " << duration_cast<microseconds>(dt0).count() << " us.\n"<< endl;
   cout << "Nombre de pairs (parallele) : " << r1
        << " obtenu en " << duration_cast<microseconds>(dt1).count() << " us.\n" << endl;
   auto [r2, dt2] = test([&] {
      int n = 0;
      for (auto debut = begin(mat); debut != end(mat); ) {
         auto [cur, m] = compter_sequentiel_m(debut, end(mat), crit, [n = 20]() mutable {
            --n;
            return n != 0;
         });
         debut = cur;
         n += m;
         // cout << '.';
      }
      return n;
   });
   cout << "Nombre de pairs (sequentiel, morcelable) : " << r2
        << " obtenu en " << duration_cast<microseconds>(dt2).count() << " us.\n" << endl;
}

// ...
enum class afficher_matrice : unsigned char { oui, non };
template <class T, class Crit, class MkPred>
   auto tests(afficher_matrice aff, ostream &os, string_view nom, const Mat2D<T> &mat, Crit crit, MkPred mkpred) {
      if (aff == afficher_matrice::oui)
         os << mat << "\n\n";
      auto [r0, dt0] = test([&] { return compter_sequentiel(mat, crit); });
      auto [r1, dt1] = test([&] { return compter_parallele(begin(mat), end(mat), crit); });
      os << r0 << " en " << duration_cast<microseconds>(dt0).count() << " us. pour " << nom << " sequentiel\n";
      os << r1 << " en " << duration_cast<microseconds>(dt1).count() << " us. pour " << nom << " parallele\n";
      int nmcx = 0;
      auto [r2, dt2] = test([&] {
         int n = 0;
         for (auto debut = begin(mat); debut != end(mat); ) {
            auto [cur, m] = compter_sequentiel_m(debut, end(mat), crit, mkpred());
            debut = cur;
            n += m;
            ++nmcx;
            // cout << '.';
         }
         return n;
      });
      os << r2 << " en " << duration_cast<microseconds>(dt2).count() << " us. pour " << nom << " sequentiel morcelable (" << nmcx << " morceaux)\n\n";
   }


int main() {
   using namespace std;
   tests(
      afficher_matrice::oui, cout,
      "nb impairs"sv,
      fabriquer_matrice<int>(10, 20, [n = -5]() mutable { return n++; }),
      [](auto n) { return n % 2 != 0; },
      [] { return[n = 5]() mutable {
         --n;
         return n != 0;
      }; }
   );
   tests(
      afficher_matrice::oui, cout,
      "nb pairs"sv,
      fabriquer_matrice<short>(10, 20, [prng = mt19937{ random_device{}() },
         d10 = uniform_int_distribution<short>{ 1,10 }]() mutable {
         return d10(prng);
      }),
      [](auto n) { return n % 2 == 0; },
      [] { return[n = 20]() mutable {
         --n;
         return n != 0;
      }; }
   );
   tests(
      afficher_matrice::non, cout,
      "nb impairs (gros)"sv,
      fabriquer_matrice<int>(1'000, 2'000, [n = -5]() mutable { return n++; }),
      [](auto n) { return n % 2 != 0; },
      [] { return[deadline = high_resolution_clock::now() + 500us]() mutable {
         return high_resolution_clock::now() < deadline;
      }; }
   );
   tests(
      afficher_matrice::oui, cout,
      "nb gros mots"sv,
      fabriquer_matrice<string>(10, 2, [prng = mt19937{ random_device{}() },
                                        d2 = uniform_int_distribution<short>{ 0,1 }]() mutable {
         return d2(prng) ? "patate"s : "supercalifragilistique"s;
      }),
      [](auto && s) { return s.size() > 10; },
      [] { return[deadline = high_resolution_clock::now() + 500us]() mutable {
         return high_resolution_clock::now() < deadline;
      }; }
   );
   tests(
      afficher_matrice::non, cout,
      "nb gros mots (gros)"sv,
      fabriquer_matrice<string>(1'000, 500, [prng = mt19937{ random_device{}() },
                                        d2 = uniform_int_distribution<short>{ 0,1 }]() mutable {
         return d2(prng) ? "patate"s : "supercalifragilistique"s;
      }),
      [](auto&& s) { return s.size() > 10; },
      [] { return[deadline = high_resolution_clock::now() + 500us]() mutable {
         return high_resolution_clock::now() < deadline;
      }; }
   );
}