Université de Sherbrooke, régulier et DGL, STR

Au menu :

• Présentation du plan de cours
• Présentation du projet de session et de quelques exemples tirés de sessions antérieures
• Mise en place de certains éléments de vocabulaire, au sens pertinent pour ce cours :
  • Synchrone (sens faible)
  • Synchrone (sens strict)
  • Asynchrone
  • Bloquant
  • Non-bloquant
  • Temps réel
  • Contraintes de temps réel (CRIB : constant, régulier, immédiat, bref)
• Discussion sur la distinction importante entre programmes en temps réel et programmes rapides, du moins dans le cas des STR stricts, et sur les nuances dans le discours quant à la question même de l'idée de temps réel, qui porte plusieurs sens, affectant différemment les gens en fonction de leur domaine d'expertise et de leur milieu de travail. Le tout dans le but de situer les un(e)s et les autres quant au contenu du cours et quant au projet de session qui vous est proposé
• Présentation du cours et des approches choisies pour y traiter des sujets qui nous y tiennent à coeur
  • Bref aparté sur la part du technique, la part du conceptuel et l'organisation du cours
• Bref tableau de façons de faire que nous utiliserons dans les exemples proposés en classe et dans les notes de cours. Ceci inclut des exemples utilisant entre autres des foncteurs, de la généricité par des templates, un algorithme standard (for_each()) et, pour le plaisir, une λ-expression
• Bref comparatif de programmes bloquant et non-bloquant
• Bref comparatif de programmes avec tâche s'exécutant à rythme régulier et à rythme constant

Dans les notes de cours, vous trouverez de la matière en lien avec cette séance dans STR – Volume 00 (vocabulaire, donc les pages ≈5..35).

Au menu :

• Présentation du plan de cours
• Présentation du projet de session et de quelques exemples tirés de sessions antérieures
• Mise en place de certains éléments de vocabulaire, au sens pertinent pour ce cours :
  • Synchrone (sens faible)
  • Synchrone (sens strict)
  • Asynchrone
  • Bloquant
  • Non-bloquant
  • Temps réel
  • Contraintes de temps réel (CRIB : constant, régulier, immédiat, bref)
• Discussion sur la distinction importante entre programmes en temps réel et programmes rapides, du moins dans le cas des STR stricts, et sur les nuances dans le discours quant à la question même de l'idée de temps réel, qui porte plusieurs sens, affectant différemment les gens en fonction de leur domaine d'expertise et de leur milieu de travail. Le tout dans le but de situer les un(e)s et les autres quant au contenu du cours et quant au projet de session qui vous est proposé
• Présentation du cours et des approches choisies pour y traiter des sujets qui nous y tiennent à coeur
  • Bref aparté sur la part du technique, la part du conceptuel et l'organisation du cours
• Bref tableau de façons de faire que nous utiliserons dans les exemples proposés en classe et dans les notes de cours. Ceci inclut des exemples utilisant entre autres des foncteurs, de la généricité par des templates, un algorithme standard (for_each()) et, pour le plaisir, une λ-expression
• Bref comparatif de programmes bloquant et non-bloquant
• Bref comparatif de programmes avec tâche s'exécutant à rythme régulier et à rythme constant

Dans les notes de cours, vous trouverez de la matière en lien avec cette séance dans STR – Volume 00 (vocabulaire, donc les pages ≈5..35).

Au menu, d'une manière teintée par notre besoin d'avoir une approche appropriée pour le développement de STR :

• Retour sur le sujet de la programmation générique en C++, qui est différente de ce qu'on trouve dans bien d'autres langages. en particulier :
  • bref inventaire de quelques-uns des principaux algorithmes standards (for_each(), bien sûr, mais aussi transform(), accumulate(), find_if(), etc.)
  • les conteneurs standards et la théorie des itérateurs
  • les foncteurs
• Sainte-Trinité
• Survol rapide de l'idiome de classe Incopiable
• Survol rapide des fonctions = delete ou = default

Mise en place d'un premier conteneur (un tableau d'entiers) implémenté selon les conventions du langage C++, en portant une attention particulière aux considérations de robustesse et d'efficacité, incluant :

• Quelques types internes et publics
• Quelques méthodes clés (size(), empty(), capacity())
• Les accès aux itérateurs (begin() et end(), en déclinaison const et non-const; cbegin() et cend())
• Quelques constructeurs (défaut, paramétrique, copie)
• L'affectation (de copie) et l'idiome d'affectation sécuritaire
• Le destructeur
• L'opérateur [] dans ses déclinaisons const et non-const
• La méthode push_back() et l'implémentation d'un algorithme de croissance (qui reste à faire)
• Opérateurs d'égalité (==, !=)

Munis des idées et techniques mises de l'avant dans cette séance, vous devriez être en mesure de comprendre les exemples dans STR – Volume 01 (voir le code des cas sous étude). Profitez de l'opportunité pour expérimenter avec ces propositions de tests, pour les modifier, pour essayer de comprendre les métriques que vous parviendrez à en tirer, etc.

#include <cstddef> // pour std::size_t
#include <algorithm>

class Tableau {
public:
   using value_type = int;
   using size_type = std::size_t;
   using pointer = value_type*;
   using const_pointer = const value_type*;
   using reference = value_type&;
   using const_reference = const value_type&;
private:
   pointer elems {};
   size_type nelems {},
             cap {};
public:
   [[nodiscard]] size_type size() const noexcept {
      return nelems;
   }
   [[nodiscard]] size_type capacity() const noexcept {
      return cap;
   }
   [[nodiscard]] bool empty() const noexcept {
      return !size();
   }
private:
   [[nodiscard]] bool full() const noexcept {
      return size() == capacity();
   }
public:
   using iterator = pointer;
   using const_iterator = const_pointer;
   [[nodiscard]] iterator begin() noexcept {
      return elems;
   }
   [[nodiscard]] const_iterator begin() const noexcept {
      return elems;
   }
   [[nodiscard]] const_iterator cbegin() const noexcept {
      return begin();
   }
   [[nodiscard]] iterator end() noexcept {
      return begin() + size();
   }
   [[nodiscard]] const_iterator end() const noexcept {
      return begin() + size();
   }
   [[nodiscard]] const_iterator cend() const noexcept {
      return end();
   }
   Tableau() = default;
   Tableau(size_type n, const_reference init)
      : elems{ new value_type[n] }, nelems{ n }, cap{ n } {
      std::fill(begin(), end(), init);
   }
   Tableau(const Tableau &autre)
      : elems{ new value_type[autre.size()] },
        nelems{ autre.size() }, cap{ autre.size() } {
      std::copy(autre.begin(), autre.end(), begin());
   }
   ~Tableau() {
      delete [] elems;
   }
   void swap(Tableau &autre) noexcept {
      using std::swap;
      swap(elems, autre.elems);
      swap(nelems, autre.nelems);
      swap(cap, autre.cap);
   }
   Tableau& operator=(const Tableau &autre) {
      Tableau{ autre }.swap(*this);
      return *this;
   }
   // ...
   reference operator[](size_type n) noexcept {
      return elems[n];
   }
   const_reference operator[](size_type n) const noexcept {
      return elems[n];
   }
   void push_back(const_reference val) {
      if (full()) grow();
      elems[size()] = val;
      ++nelems;
   }
private:
   void grow() {
      const size_type new_cap = capacity()? capacity() * 2 : 64; // hum
      auto p = new value_type[new_cap];
      std::copy(begin(), end(), p);
      delete[] elems;
      cap = new_cap;
      elems = p;
   }
};

Dans les notes de cours, comme mentionné dans le paragraphe précédent, vous trouverez de la matière en lien avec cette séance dans STR – Volume 01.

Au menu, d'une manière teintée par notre besoin d'avoir une approche appropriée pour le développement de STR :

• Retour sur le sujet de la programmation générique en C++, qui est différente de ce qu'on trouve dans bien d'autres langages. en particulier :
  • bref inventaire de quelques-uns des principaux algorithmes standards (for_each(), bien sûr, mais aussi transform(), accumulate(), find_if(), etc.)
  • les conteneurs standards et la théorie des itérateurs
  • les foncteurs
• Sainte-Trinité
• Survol rapide de l'idiome de classe Incopiable
• Survol rapide des fonctions = delete ou = default

Mise en place d'un premier conteneur (un tableau d'entiers) implémenté selon les conventions du langage C++, en portant une attention particulière aux considérations de robustesse et d'efficacité, incluant :

• Quelques types internes et publics
• Quelques méthodes clés (size(), empty(), capacity())
• Les accès aux itérateurs (begin() et end(), en déclinaison const et non-const; cbegin() et cend())
• Quelques constructeurs (défaut, paramétrique, copie)
• L'affectation (de copie) et l'idiome d'affectation sécuritaire
• Le destructeur
• L'opérateur [] dans ses déclinaisons const et non-const
• La méthode push_back() et l'implémentation d'un algorithme de croissance (qui reste à faire)
• Opérateurs d'égalité (==, !=)

Munis des idées et techniques mises de l'avant dans cette séance, vous devriez être en mesure de comprendre les exemples dans STR – Volume 01 (voir le code des cas sous étude). Profitez de l'opportunité pour expérimenter avec ces propositions de tests, pour les modifier, pour essayer de comprendre les métriques que vous parviendrez à en tirer, etc.

#include <cstddef> // pour std::size_t
#include <algorithm>

class Tableau {
public:
   using value_type = int;
   using size_type = std::size_t;
   using pointer = value_type*;
   using const_pointer = const value_type*;
   using reference = value_type&;
   using const_reference = const value_type&;
private:
   pointer elems {};
   size_type nelems {},
             cap {};
public:
   [[nodiscard]] size_type size() const noexcept {
      return nelems;
   }
   [[nodiscard]] size_type capacity() const noexcept {
      return cap;
   }
   [[nodiscard]] bool empty() const noexcept {
      return !size();
   }
private:
   [[nodiscard]] bool full() const noexcept {
      return size() == capacity();
   }
public:
   using iterator = pointer;
   using const_iterator = const_pointer;
   [[nodiscard]] iterator begin() noexcept {
      return elems;
   }
   [[nodiscard]] const_iterator begin() const noexcept {
      return elems;
   }
   [[nodiscard]] const_iterator cbegin() const noexcept {
      return begin();
   }
   [[nodiscard]] iterator end() noexcept {
      return begin() + size();
   }
   [[nodiscard]] const_iterator end() const noexcept {
      return begin() + size();
   }
   [[nodiscard]] const_iterator cend() const noexcept {
      return end();
   }
   Tableau() = default;
   Tableau(size_type n, const_reference init)
      : elems{ new value_type[n] }, nelems{ n }, cap{ n } {
      std::fill(begin(), end(), init);
   }
   Tableau(const Tableau &autre)
      : elems{ new value_type[autre.size()] },
        nelems{ autre.size() }, cap{ autre.size() } {
      std::copy(autre.begin(), autre.end(), begin());
   }
   ~Tableau() {
      delete [] elems;
   }
   void swap(Tableau &autre) noexcept {
      using std::swap;
      swap(elems, autre.elems);
      swap(nelems, autre.nelems);
      swap(cap, autre.cap);
   }
   Tableau& operator=(const Tableau &autre) {
      Tableau{ autre }.swap(*this);
      return *this;
   }
   // ...
   reference operator[](size_type n) noexcept {
      return elems[n];
   }
   const_reference operator[](size_type n) const noexcept {
      return elems[n];
   }
   void push_back(const_reference val) {
      if (full()) grow();
      elems[size()] = val;
      ++nelems;
   }
private:
   void grow() {
      const size_type new_cap = capacity()? capacity() * 2 : 64; // hum
      auto p = new value_type[new_cap];
      std::copy(begin(), end(), p);
      delete[] elems;
      cap = new_cap;
      elems = p;
   }
};

Dans les notes de cours, comme mentionné dans le paragraphe précédent, vous trouverez de la matière en lien avec cette séance dans STR – Volume 01.

Au menu :

• Q00 (pour des comparatifs, voir https://quick-bench.com/q/4fLEJys8fG5ShDIsfHgWrodyBhw)
• Compléter l'implémentation du tableau d'entiers débuté à S01 :
  • L'implémentation d'un algorithme de croissance
  • Sémantique de mouvement
    • constructeur de mouvement
    • affectation de mouvement
  • Comprendre le mouvement à l'aide d'une classe Noisy

#include <cstddef> // pour std::size_t
#include <algorithm>

class Tableau {
public:
   using value_type = int;
   using size_type = std::size_t;
   using pointer = value_type*;
   using const_pointer = const value_type*;
   using reference = value_type&;
   using const_reference = const value_type&;
private:
   pointer elems {};
   size_type nelems {},
             cap {};
public:
   [[nodiscard]] size_type size() const noexcept {
      return nelems;
   }
   [[nodiscard]] size_type capacity() const noexcept {
      return cap;
   }
   [[nodiscard]] bool empty() const noexcept {
      return !size();
   }
private:
   [[nodiscard]] bool full() const noexcept {
      return size() == capacity();
   }
public:
   using iterator = pointer;
   using const_iterator = const_pointer;
   [[nodiscard]] iterator begin() noexcept {
      return elems;
   }
   [[nodiscard]] const_iterator begin() const noexcept {
      return elems;
   }
   [[nodiscard]] const_iterator cbegin() const noexcept {
      return begin();
   }
   [[nodiscard]] iterator end() noexcept {
      return begin() + size();
   }
   [[nodiscard]] const_iterator end() const noexcept {
      return begin() + size();
   }
   [[nodiscard]] const_iterator cend() const noexcept {
      return end();
   }
   Tableau() = default;
   Tableau(size_type n, const_reference init)
      : cap{ n }, nelems{ n }, elems{ new value_type[n] } {
      std::fill(begin(), end(), init);
   }
   Tableau(const Tableau &autre)
      : elems{ new value_type[autre.size()] },
        nelems{ autre.size() }, cap{ autre.size() } {
      std::copy(autre.begin(), autre.end(), begin());
   }
   ~Tableau() {
      delete [] elems;
   }
   void swap(Tableau &autre) noexcept {
      using std::swap;
      swap(elems, autre.elems);
      swap(nelems, autre.nelems);
      swap(cap, autre.cap);
   }
   Tableau& operator=(const Tableau &autre) {
      Tableau{ autre }.swap(*this);
      return *this;
   }
   Tableau(Tableau &&autre) noexcept
      : elems{ std::exchange(autre.elems, nullptr) },
        nelems{ std::exchange(autre.nelems, 0) },
        cap{ std::exchange(autre.cap, 0) } {
   }
   Tableau& operator=(Tableau &&autre) noexcept {
      Tableau{ std::move(autre) }.swap(*this);
      return *this;
   }
   reference operator[](size_type n) noexcept {
      return elems[n];
   }
   const_reference operator[](size_type n) const noexcept {
      return elems[n];
   }
   void push_back(const_reference val) {
      if (full()) grow();
      elems[size()] = val;
      ++nelems;
   }
private:
   void grow() {
      const size_type new_cap = capacity()? capacity() * 2 : 128;
      auto p = new value_type[new_cap];
      std::copy(begin(), end(), p);
      delete[] elems;
      cap = new_cap;
      elems = p;
   }
public:
   bool operator==(const Tableau &autre) const noexcept {
      return size() == autre.size() &&
             std::equal(begin(), end(), autre.begin());
   }
   bool operator!=(const Tableau &autre) const noexcept {
      return !(*this == autre);
   }
};


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

template <class F, class ... Args>
   auto tester(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 };
   }

vector<double> f(vector<double> v) {
   transform(begin(v), end(v), begin(v), [](double x) { return sqrt(x); });
   return v;
}

void g(vector<double> &v) {
   transform(begin(v), end(v), begin(v), [](double x) { return sqrt(x); });
}

int main() {
   enum { N = 10'000'000 };
   vector<double> v(N);
   iota(begin(v), end(v), 1.0);
   auto [r0,dt0] = tester([v]() mutable {
      v = f(v);
      return v.back();
   });
   auto [r1,dt1] = tester([v]() mutable {
      g(v);
      return v.back();
   });
   auto [r2,dt2] = tester([v]() mutable {
      v = f(std::move(v));
      return v.back();
   });
   cout << "v = f(v)            : " << duration_cast<microseconds>(dt0)
        << endl;
   cout << "g(v)                : " << duration_cast<microseconds>(dt1)
        << endl;
   cout << "v = f(std::move(v)) : " << duration_cast<microseconds>(dt2)
        << endl;
}

• Survol rapide des traits
  • Vous trouverez quelques exemples amusants en ce sens dans cet article sur la métaprogrammation, mais notez que l'article va loin alors que nous ne faisons que commencer...
• Petite parenthèse distrayante avec assez_proches()
  • Implémentation par tag dispatching
  • Implémentation par enable_if
  • Implémentation par if constexpr
  • Introduction aux concepts
• L'exemple amusant d'un trait est_convertible

Dans les notes de cours, vous trouverez de la matière en lien avec cette séance dans STR – Volume 00, annexes 00 et 01, mais vous en trouverez surtout dans les liens ci-dessus.

Au menu :

• Q00 (pour des comparatifs, voir https://quick-bench.com/q/4fLEJys8fG5ShDIsfHgWrodyBhw)
• Compléter l'implémentation du tableau d'entiers débuté à S01 :
  • L'implémentation d'un algorithme de croissance
  • Sémantique de mouvement
    • constructeur de mouvement
    • affectation de mouvement
  • Comprendre le mouvement à l'aide d'une classe Noisy

#include <cstddef> // pour std::size_t
#include <algorithm>

class Tableau {
public:
   using value_type = int;
   using size_type = std::size_t;
   using pointer = value_type*;
   using const_pointer = const value_type*;
   using reference = value_type&;
   using const_reference = const value_type&;
private:
   pointer elems {};
   size_type nelems {},
             cap {};
public:
   [[nodiscard]] size_type size() const noexcept {
      return nelems;
   }
   [[nodiscard]] size_type capacity() const noexcept {
      return cap;
   }
   [[nodiscard]] bool empty() const noexcept {
      return !size();
   }
private:
   [[nodiscard]] bool full() const noexcept {
      return size() == capacity();
   }
public:
   using iterator = pointer;
   using const_iterator = const_pointer;
   [[nodiscard]] iterator begin() noexcept {
      return elems;
   }
   [[nodiscard]] const_iterator begin() const noexcept {
      return elems;
   }
   [[nodiscard]] const_iterator cbegin() const noexcept {
      return begin();
   }
   [[nodiscard]] iterator end() noexcept {
      return begin() + size();
   }
   [[nodiscard]] const_iterator end() const noexcept {
      return begin() + size();
   }
   [[nodiscard]] const_iterator cend() const noexcept {
      return end();
   }
   Tableau() = default;
   Tableau(size_type n, const_reference init)
      : cap{ n }, nelems{ n }, elems{ new value_type[n] } {
      std::fill(begin(), end(), init);
   }
   Tableau(const Tableau &autre)
      : elems{ new value_type[autre.size()] },
        nelems{ autre.size() }, cap{ autre.size() } {
      std::copy(autre.begin(), autre.end(), begin());
   }
   ~Tableau() {
      delete [] elems;
   }
   void swap(Tableau &autre) noexcept {
      using std::swap;
      swap(elems, autre.elems);
      swap(nelems, autre.nelems);
      swap(cap, autre.cap);
   }
   Tableau& operator=(const Tableau &autre) {
      Tableau{ autre }.swap(*this);
      return *this;
   }
   Tableau(Tableau &&autre) noexcept
      : elems{ std::exchange(autre.elems, nullptr) },
        nelems{ std::exchange(autre.nelems, 0) },
        cap{ std::exchange(autre.cap, 0) } {
   }
   Tableau& operator=(Tableau &&autre) noexcept {
      Tableau{ std::move(autre) }.swap(*this);
      return *this;
   }
   reference operator[](size_type n) noexcept {
      return elems[n];
   }
   const_reference operator[](size_type n) const noexcept {
      return elems[n];
   }
   void push_back(const_reference val) {
      if (full()) grow();
      elems[size()] = val;
      ++nelems;
   }
private:
   void grow() {
      const size_type new_cap = capacity()? capacity() * 2 : 128;
      auto p = new value_type[new_cap];
      std::copy(begin(), end(), p);
      delete[] elems;
      cap = new_cap;
      elems = p;
   }
public:
   bool operator==(const Tableau &autre) const noexcept {
      return size() == autre.size() &&
             std::equal(begin(), end(), autre.begin());
   }
   bool operator!=(const Tableau &autre) const noexcept {
      return !(*this == autre);
   }
};


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

template <class F, class ... Args>
   auto tester(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 };
   }

vector<double> f(vector<double> v) {
   transform(begin(v), end(v), begin(v), [](double x) { return sqrt(x); });
   return v;
}

void g(vector<double> &v) {
   transform(begin(v), end(v), begin(v), [](double x) { return sqrt(x); });
}

int main() {
   enum { N = 10'000'000 };
   vector<double> v(N);
   iota(begin(v), end(v), 1.0);
   auto [r0,dt0] = tester([v]() mutable {
      v = f(v);
      return v.back();
   });
   auto [r1,dt1] = tester([v]() mutable {
      g(v);
      return v.back();
   });
   auto [r2,dt2] = tester([v]() mutable {
      v = f(std::move(v));
      return v.back();
   });
   cout << "v = f(v)            : " << duration_cast<microseconds>(dt0)
        << endl;
   cout << "g(v)                : " << duration_cast<microseconds>(dt1)
        << endl;
   cout << "v = f(std::move(v)) : " << duration_cast<microseconds>(dt2)
        << endl;
}

• Survol rapide des traits
  • Vous trouverez quelques exemples amusants en ce sens dans cet article sur la métaprogrammation, mais notez que l'article va loin alors que nous ne faisons que commencer...
• Petite parenthèse distrayante avec assez_proches()
  • Implémentation par tag dispatching
  • Implémentation par enable_if
  • Implémentation par if constexpr
  • Introduction aux concepts
• L'exemple amusant d'un trait est_convertible

Dans les notes de cours, vous trouverez de la matière en lien avec cette séance dans STR – Volume 00, annexes 00 et 01, mais vous en trouverez surtout dans les liens ci-dessus.

• Q01
• Bref retour sur Q00
• Quelques mots sur cette optimisation qu'on nomme le Function Inlining et nuances quant aux capacités des compilateurs
  • Idée de qualité d'implémentation (Quality of Implementation,  QoI)
  • Enjeux comme le Whole Program Optimization ou le Link Time Optimization
• Quelques mots sur les concepts
  • J'ai utilisé des diapos que j'ai mis à votre disposition sur Intro-concepts.pdf
• Quelques mots sur la préconstruction
• Petite excursion dans le monde des itérateurs : catégories, opérations, forces, faiblesses, usages
• Poursuite de l'examen des itérateurs, en lien avec la fonction distance()
• Poursuite de l'examen des itérateurs et des traits, en lien avec le calcul de la moyenne

Dans les notes de cours, vous trouverez de la matière en lien avec cette séance dans STR – Volume 00, annexes 00 et 01, mais vous en trouverez surtout dans les liens ci-dessus.

#include <iterator>
using namespace std; // bof
//
// j'ai appelé la fonction distance_ pour éviter les
// conflits de nom avec std::distance
//
template <class It>
   auto distance_(It debut, It fin, forward_iterator_tag) {
      typename iterator_traits<It>::difference_type n{};
      for(; debut != fin; ++debut)
         ++n;
      return n;
   }
template <class It>
   auto distance_(It debut, It fin, random_access_iterator_tag) {
      return fin - debut;
   }
template <class It>
   auto distance_(It debut, It fin) {
      return distance_(
         debut, fin, typename iterator_traits<
            It
         >::iterator_category{}
      );
   }

• Q01
• Bref retour sur Q00
• Quelques mots sur cette optimisation qu'on nomme le Function Inlining et nuances quant aux capacités des compilateurs
  • Idée de qualité d'implémentation (Quality of Implementation,  QoI)
  • Enjeux comme le Whole Program Optimization ou le Link Time Optimization
• Quelques mots sur les concepts
  • J'ai utilisé des diapos que j'ai mis à votre disposition sur Intro-concepts.pdf
• Quelques mots sur la préconstruction
• Petite excursion dans le monde des itérateurs : catégories, opérations, forces, faiblesses, usages
• Poursuite de l'examen des itérateurs, en lien avec la fonction distance()
• Poursuite de l'examen des itérateurs et des traits, en lien avec le calcul de la moyenne

Dans les notes de cours, vous trouverez de la matière en lien avec cette séance dans STR – Volume 00, annexes 00 et 01, mais vous en trouverez surtout dans les liens ci-dessus.

#include <iterator>
using namespace std; // bof
//
// j'ai appelé la fonction distance_ pour éviter les
// conflits de nom avec std::distance
//
template <class It>
   auto distance_(It debut, It fin, forward_iterator_tag) {
      typename iterator_traits<It>::difference_type n{};
      for(; debut != fin; ++debut)
         ++n;
      return n;
   }
template <class It>
   auto distance_(It debut, It fin, random_access_iterator_tag) {
      return fin - debut;
   }
template <class It>
   auto distance_(It debut, It fin) {
      return distance_(
         debut, fin, typename iterator_traits<
            It
         >::iterator_category{}
      );
   }

Au menu :

• Q02
• Bref retour sur Q01
• Étude du cas d'un opérateur de transtypage maison, et de son optimisation à partir de traits
  • pour une implémentation sinon complète, à tout le moins utilisable en pratique, voir ../../Sources/lexical_cast_complet.html
• Implémentation d'un tableau générique, avec toutes les subtilités que cela implique

#include <cstddef>#include <algorithm>
#include <initializer_list>
#include <utility>
template <class T>
class Tableau {
public:
   using value_type = T;
   using size_type = std::size_t;
   using pointer = value_type*;
   using const_pointer = const value_type*;
   using reference = value_type&;
   using const_reference = const value_type&;
private:
   pointer elems {};
   size_type nelems {},
             cap {};
public:
   [[nodiscard]] size_type size() const noexcept {
      return nelems;
   }
   [[nodiscard]] size_type capacity() const noexcept {
      return cap;
   }
   [[nodiscard]] bool empty() const noexcept {
      return !size();
   }
private:
   [[nodiscard]] bool full() const noexcept {
      return size() == capacity();
   }
public:
   using iterator = pointer;
   using const_iterator = const_pointer;
   [[nodiscard]] iterator begin() noexcept {
      return elems;
   }
   [[nodiscard]] const_iterator begin() const noexcept {
      return elems;
   }
   [[nodiscard]] const_iterator cbegin() const noexcept {
      return begin();
   }
   [[nodiscard]] iterator end() noexcept {
      return begin() + size();
   }
   [[nodiscard]] const_iterator end() const noexcept {
      return begin() + size();
   }
   [[nodiscard]] const_iterator cend() const noexcept {
      return end();
   }
   Tableau() = default;
   Tableau(std::initializer_list<value_type> lst)
      : elems{ new value_type[lst.size()] },
        nelems{ lst.size() }, cap{ lst.size() } {
      try {
         std::copy(lst.begin(), lst.end(), begin());
      } catch(...) {
         delete[] elems;
         throw;
      }
   }
   //
   // Notez que le constructeur ci-dessous peut bénéficier
   // du recours à enable_if pour éviter certaines ambiguïtés
   //
   Tableau(size_type n, const_reference init)
      : elems{ new value_type[n] }, nelems{ n }, cap{ n } {
      try {
         std::fill(begin(), end(), init);
      } catch(...) {
         delete[] elems;
         throw;
      }
   }
   Tableau(const Tableau &autre)
      : elems{ new value_type[autre.size()] },
        nelems{ autre.size() }, cap{ autre.size() } {
      try {
         std::copy(autre.begin(), autre.end(), begin());
      } catch(...) {
         delete[] elems;
         throw;
      }
   }
   //
   // Notez que le constructeur ci-dessous peut bénéficier
   // du recours à enable_if pour éviter certaines ambiguïtés
   //
   template <class It>
      Tableau(It debut, It fin)
         : nelems{ std::distance(debut, fin) } {
         cap = size();
         elems = new value_type[size()];
         try {
            std::copy(debut, fin, begin());
         } catch(...) {
            delete[] elems;
            throw;
         }
      }
   template <class U>
      Tableau(const Tableau<U> &autre)
         : elems{ new value_type[autre.size()] },
           nelems{ autre.size() }, cap{ autre.size() } {
         try {
            std::copy(autre.begin(), autre.end(), begin());
         } catch(...) {
            delete[] elems;
            throw;
         }
      }
   template <class U>
      Tableau& operator=(const Tableau<U> &autre) {
         Tableau{ autre }.swap(*this);
         return *this;
      }
   ~Tableau() {
      delete[] elems;
   }
   void swap(Tableau &autre) noexcept {
      using std::swap;
      swap(elems, autre.elems);
      swap(nelems, autre.nelems);
      swap(cap, autre.cap);
   }
   Tableau& operator=(const Tableau &autre) {
      Tableau{ autre }.swap(*this);
      return *this;
   }
   reference operator[](size_type n) noexcept {
      return elems[n];
   }
   const_reference operator[](size_type n) const noexcept {
      return elems[n];
   }
   void push_back(const_reference val) {
      if (full()) grow();
      elems[size()] = val;
      ++nelems;
   }
private:
   void grow() {
      const size_type new_cap = capacity() ? capacity() * 2 : 128; // hum
      auto p = new value_type[new_cap];
      try {
         std::copy(begin(), end(), p);
         delete[]elems;
         cap = new_cap;
         elems = p;
      } catch(...) {
         delete [] p;
         throw;
      }
   }
public:
   bool operator==(const Tableau &autre) const  {
      return size() == autre.size() &&
             std::equal(begin(), end(), autre.begin());
   }
   bool operator!=(const Tableau &autre) const  {
      return !(*this == autre);
   }
   Tableau(Tableau &&autre) noexcept
      : elems{ std::exchange(autre.elems, nullptr) },
        nelems{ std::exchange(autre.nelems, 0) },
        cap{ std::exchange(autre.cap, 0) } {
   }
   Tableau& operator=(Tableau &&autre) noexcept {
      delete[] elems;
      elems = std::exchange(autre.elems, nullptr);
      nelems = std::exchange(autre.nelems, 0);
      cap = std::exchange(autre.cap, 0);
      return *this;
   }
};

• Discussion sommaire sur les pointeurs intelligents (voir smart_ptr.pdf pour la présentation électronique sur le sujet)

#include <cstddef>
#include <algorithm>
#include <initializer_list>
#include <memory>

template <class T>
class Tableau {
public:
   using value_type = T;
   using size_type = std::size_t;
   using pointer = value_type*;
   using const_pointer = const value_type*;
   using reference = value_type&;
   using const_reference = const value_type&;
private:
   std::unique_ptr<value_type[]> elems;
   size_type nelems{},
             cap{};
public:
   [[nodiscard]] size_type size() const noexcept {
      return nelems;
   }
   [[nodiscard]] size_type capacity() const noexcept {
      return cap;
   }
   [[nodiscard]] bool empty() const noexcept {
      return !size();
   }
private:
   [[nodiscard]] bool full() const noexcept {
      return size() == capacity();
   }
public:
   using iterator = pointer;
   using const_iterator = const_pointer;
   [[nodiscard]] iterator begin() noexcept {
      return elems.get();
   }
   [[nodiscard]] const_iterator begin() const noexcept {
      return elems.get();
   }
   [[nodiscard]] const_iterator cbegin() const noexcept {
      return elems.get();
   }
   [[nodiscard]] iterator end() noexcept {
      return begin() + size();
   }
   [[nodiscard]] const_iterator end() const noexcept {
      return begin() + size();
   }
   [[nodiscard]] const_iterator cend() const noexcept {
      return begin() + size();
   }
   Tableau() = default;
   Tableau(std::initializer_list<value_type> lst)
      : elems{ new value_type[lst.size()] },
        nelems{ lst.size() }, cap{ lst.size() } {
      std::copy(lst.begin(), lst.end(), begin());
   }
   Tableau(size_type n, const value_type &init)
      : elems{ new value_type[n] }, nelems{ n } , cap{ n }{
      std::fill(begin(), end(), init);
   }
   Tableau(const Tableau &autre)
      : elems{ new value_type[autre.size()] },
        nelems{ autre.size() }, cap{ autre.size() } {
      std::copy(autre.begin(), autre.end(), begin());
   }
   template <class It>
   Tableau(It debut, It fin)
      : nelems{ std::distance(debut, fin) } {
      cap = size();
      elems = make_unique<value_type[]>{ size() };
      std::copy(debut, fin, begin());
   }
   template <class U>
   Tableau(const Tableau<U> &autre)
      : elems{ new value_type[autre.size()] },
        nelems{ autre.size() }, cap{ autre.size() } {
      std::copy(autre.begin(), autre.end(), begin());
   }
   template <class U>
   Tableau& operator=(const Tableau<U> &autre) {
      Tableau{ autre }.swap(*this);
      return *this;
   }
   ~Tableau() = default;
   void swap(Tableau &autre) noexcept {
      using std::swap;
      swap(elems, autre.elems);
      swap(nelems, autre.nelems);
      swap(cap, autre.cap);
   }
   Tableau& operator=(const Tableau &autre) {
      Tableau{ autre }.swap(*this);
      return *this;
   }
   reference operator[](size_type n) noexcept {
      return elems[n];
   }
   const_reference operator[](size_type n) const noexcept {
      return elems[n];
   }
   void push_back(const_reference val) {
      if (full()) grow();
      elems[size()] = val;
      ++nelems;
   }
private:
   void grow() {
      using namespace std;
      const size_type new_cap = capacity() ? capacity() * 2 : 128;
      unique_ptr<value_type[]> p{ new value_type[new_cap] };
      copy(begin(), end(), p);
      cap = new_cap;
      swap(p, elems);
   }
public:
   bool operator==(const Tableau &autre) const  {
      return size() == autre.size() &&
             std::equal(begin(), end(), autre.begin());
   }
   bool operator!=(const Tableau &autre) const  {
      return !(*this == autre);
   }
   Tableau(Tableau &&autre) = default;
   Tableau& operator=(Tableau &&autre) = default;
};

• Premiers pas dans la gestion intelligente de la mémoire :
  • survol des mécanismes inhérents au langage C (std::malloc() et std::free()) et des implications de leurs signatures respectives

Au menu :

• Q02
• Bref retour sur Q01
• Étude du cas d'un opérateur de transtypage maison, et de son optimisation à partir de traits
  • pour une implémentation sinon complète, à tout le moins utilisable en pratique, voir ../../Sources/lexical_cast_complet.html
• Implémentation d'un tableau générique, avec toutes les subtilités que cela implique

#include <cstddef>#include <algorithm>
#include <initializer_list>
#include <utility>
template <class T>
class Tableau {
public:
   using value_type = T;
   using size_type = std::size_t;
   using pointer = value_type*;
   using const_pointer = const value_type*;
   using reference = value_type&;
   using const_reference = const value_type&;
private:
   pointer elems {};
   size_type nelems {},
             cap {};
public:
   [[nodiscard]] size_type size() const noexcept {
      return nelems;
   }
   [[nodiscard]] size_type capacity() const noexcept {
      return cap;
   }
   [[nodiscard]] bool empty() const noexcept {
      return !size();
   }
private:
   [[nodiscard]] bool full() const noexcept {
      return size() == capacity();
   }
public:
   using iterator = pointer;
   using const_iterator = const_pointer;
   [[nodiscard]] iterator begin() noexcept {
      return elems;
   }
   [[nodiscard]] const_iterator begin() const noexcept {
      return elems;
   }
   [[nodiscard]] const_iterator cbegin() const noexcept {
      return begin();
   }
   [[nodiscard]] iterator end() noexcept {
      return begin() + size();
   }
   [[nodiscard]] const_iterator end() const noexcept {
      return begin() + size();
   }
   [[nodiscard]] const_iterator cend() const noexcept {
      return end();
   }
   Tableau() = default;
   Tableau(std::initializer_list<value_type> lst)
      : elems{ new value_type[lst.size()] },
        nelems{ lst.size() }, cap{ lst.size() } {
      try {
         std::copy(lst.begin(), lst.end(), begin());
      } catch(...) {
         delete[] elems;
         throw;
      }
   }
   //
   // Notez que le constructeur ci-dessous peut bénéficier
   // du recours à enable_if pour éviter certaines ambiguïtés
   //
   Tableau(size_type n, const_reference init)
      : elems{ new value_type[n] }, nelems{ n }, cap{ n } {
      try {
         std::fill(begin(), end(), init);
      } catch(...) {
         delete[] elems;
         throw;
      }
   }
   Tableau(const Tableau &autre)
      : elems{ new value_type[autre.size()] },
        nelems{ autre.size() }, cap{ autre.size() } {
      try {
         std::copy(autre.begin(), autre.end(), begin());
      } catch(...) {
         delete[] elems;
         throw;
      }
   }
   //
   // Notez que le constructeur ci-dessous peut bénéficier
   // du recours à enable_if pour éviter certaines ambiguïtés
   //
   template <class It>
      Tableau(It debut, It fin)
         : nelems{ std::distance(debut, fin) } {
         cap = size();
         elems = new value_type[size()];
         try {
            std::copy(debut, fin, begin());
         } catch(...) {
            delete[] elems;
            throw;
         }
      }
   template <class U>
      Tableau(const Tableau<U> &autre)
         : elems{ new value_type[autre.size()] },
           nelems{ autre.size() }, cap{ autre.size() } {
         try {
            std::copy(autre.begin(), autre.end(), begin());
         } catch(...) {
            delete[] elems;
            throw;
         }
      }
   template <class U>
      Tableau& operator=(const Tableau<U> &autre) {
         Tableau{ autre }.swap(*this);
         return *this;
      }
   ~Tableau() {
      delete[] elems;
   }
   void swap(Tableau &autre) noexcept {
      using std::swap;
      swap(elems, autre.elems);
      swap(nelems, autre.nelems);
      swap(cap, autre.cap);
   }
   Tableau& operator=(const Tableau &autre) {
      Tableau{ autre }.swap(*this);
      return *this;
   }
   reference operator[](size_type n) noexcept {
      return elems[n];
   }
   const_reference operator[](size_type n) const noexcept {
      return elems[n];
   }
   void push_back(const_reference val) {
      if (full()) grow();
      elems[size()] = val;
      ++nelems;
   }
private:
   void grow() {
      const size_type new_cap = capacity() ? capacity() * 2 : 128; // hum
      auto p = new value_type[new_cap];
      try {
         std::copy(begin(), end(), p);
         delete[]elems;
         cap = new_cap;
         elems = p;
      } catch(...) {
         delete [] p;
         throw;
      }
   }
public:
   bool operator==(const Tableau &autre) const  {
      return size() == autre.size() &&
             std::equal(begin(), end(), autre.begin());
   }
   bool operator!=(const Tableau &autre) const  {
      return !(*this == autre);
   }
   Tableau(Tableau &&autre) noexcept
      : elems{ std::exchange(autre.elems, nullptr) },
        nelems{ std::exchange(autre.nelems, 0) },
        cap{ std::exchange(autre.cap, 0) } {
   }
   Tableau& operator=(Tableau &&autre) noexcept {
      delete[] elems;
      elems = std::exchange(autre.elems, nullptr);
      nelems = std::exchange(autre.nelems, 0);
      cap = std::exchange(autre.cap, 0);
      return *this;
   }
};

• Discussion sommaire sur les pointeurs intelligents (voir smart_ptr.pdf pour la présentation électronique sur le sujet)

#include <cstddef>
#include <algorithm>
#include <initializer_list>
#include <memory>

template <class T>
class Tableau {
public:
   using value_type = T;
   using size_type = std::size_t;
   using pointer = value_type*;
   using const_pointer = const value_type*;
   using reference = value_type&;
   using const_reference = const value_type&;
private:
   std::unique_ptr<value_type[]> elems;
   size_type nelems{},
             cap{};
public:
   [[nodiscard]] size_type size() const noexcept {
      return nelems;
   }
   [[nodiscard]] size_type capacity() const noexcept {
      return cap;
   }
   [[nodiscard]] bool empty() const noexcept {
      return !size();
   }
private:
   [[nodiscard]] bool full() const noexcept {
      return size() == capacity();
   }
public:
   using iterator = pointer;
   using const_iterator = const_pointer;
   [[nodiscard]] iterator begin() noexcept {
      return elems.get();
   }
   [[nodiscard]] const_iterator begin() const noexcept {
      return elems.get();
   }
   [[nodiscard]] const_iterator cbegin() const noexcept {
      return elems.get();
   }
   [[nodiscard]] iterator end() noexcept {
      return begin() + size();
   }
   [[nodiscard]] const_iterator end() const noexcept {
      return begin() + size();
   }
   [[nodiscard]] const_iterator cend() const noexcept {
      return begin() + size();
   }
   Tableau() = default;
   Tableau(std::initializer_list<value_type> lst)
      : elems{ new value_type[lst.size()] },
        nelems{ lst.size() }, cap{ lst.size() } {
      std::copy(lst.begin(), lst.end(), begin());
   }
   Tableau(size_type n, const value_type &init)
      : elems{ new value_type[n] }, nelems{ n } , cap{ n }{
      std::fill(begin(), end(), init);
   }
   Tableau(const Tableau &autre)
      : elems{ new value_type[autre.size()] },
        nelems{ autre.size() }, cap{ autre.size() } {
      std::copy(autre.begin(), autre.end(), begin());
   }
   template <class It>
   Tableau(It debut, It fin)
      : nelems{ std::distance(debut, fin) } {
      cap = size();
      elems = make_unique<value_type[]>{ size() };
      std::copy(debut, fin, begin());
   }
   template <class U>
   Tableau(const Tableau<U> &autre)
      : elems{ new value_type[autre.size()] },
        nelems{ autre.size() }, cap{ autre.size() } {
      std::copy(autre.begin(), autre.end(), begin());
   }
   template <class U>
   Tableau& operator=(const Tableau<U> &autre) {
      Tableau{ autre }.swap(*this);
      return *this;
   }
   ~Tableau() = default;
   void swap(Tableau &autre) noexcept {
      using std::swap;
      swap(elems, autre.elems);
      swap(nelems, autre.nelems);
      swap(cap, autre.cap);
   }
   Tableau& operator=(const Tableau &autre) {
      Tableau{ autre }.swap(*this);
      return *this;
   }
   reference operator[](size_type n) noexcept {
      return elems[n];
   }
   const_reference operator[](size_type n) const noexcept {
      return elems[n];
   }
   void push_back(const_reference val) {
      if (full()) grow();
      elems[size()] = val;
      ++nelems;
   }
private:
   void grow() {
      using namespace std;
      const size_type new_cap = capacity() ? capacity() * 2 : 128;
      unique_ptr<value_type[]> p{ new value_type[new_cap] };
      copy(begin(), end(), p);
      cap = new_cap;
      swap(p, elems);
   }
public:
   bool operator==(const Tableau &autre) const  {
      return size() == autre.size() &&
             std::equal(begin(), end(), autre.begin());
   }
   bool operator!=(const Tableau &autre) const  {
      return !(*this == autre);
   }
   Tableau(Tableau &&autre) = default;
   Tableau& operator=(Tableau &&autre) = default;
};

• Premiers pas dans la gestion intelligente de la mémoire :
  • survol des mécanismes inhérents au langage C (std::malloc() et std::free()) et des implications de leurs signatures respectives

Au menu :

• Q03
• Premiers pas dans la gestion intelligente de la mémoire :
  • survol des mécanismes inhérents au langage C (std::malloc() et std::free()) et des implications de leurs signatures respectives
  • spécialisation des services de C++ :
    • sous forme de méthodes d'instance
  • les arénas, qui permettent de gérer des zones de mémoire choisies

Au menu :

• Q03
• Premiers pas dans la gestion intelligente de la mémoire :
  • survol des mécanismes inhérents au langage C (std::malloc() et std::free()) et des implications de leurs signatures respectives
  • spécialisation des services de C++ :
    • sous forme de méthodes d'instance
  • les arénas, qui permettent de gérer des zones de mémoire choisies

Au menu :

• Q04
• Retour sur Q03
• Retour sur Q02, en particulier :
  • La question de la prochaine minute
  • La question des exceptions
• À la veille de la pause de mi-session, on se fait plaisir :
  • Introduction de constexpr
  • Littéraux maison
  • Petit tour amusant du côté des templates variadiques
    • Le Perfect Forwarding
    • Comment notre fonction test(f,args...) fonctionne
  • Quelques mots sur les Fold Expressions

Au menu :

• Q04
• Retour sur Q03
• Retour sur Q02, en particulier :
  • La question de la prochaine minute
  • La question des exceptions
• À la veille de la pause de mi-session, on se fait plaisir :
  • Introduction de constexpr
  • Littéraux maison
  • Petit tour amusant du côté des templates variadiques
    • Le Perfect Forwarding
    • Comment notre fonction test(f,args...) fonctionne
  • Quelques mots sur les Fold Expressions

Au menu :

• Q04
• Q05
• Retour sur le dossier de la gestion de l'allocation dynamique de mémoire :
  • Implémenter un conteneur tirant profit des mécanismes distinguant allocation et initialisation
  • Rédiger un conteneur générique du calibre de std::vector, donc générique, robuste et rapide
    • sans allocateur
    • avec allocateur
  • Algorithmes standards sur de la mémoire brute et différences avec algorithmes standards usuels
    • comparaison de std::unitialized_fill() avec std::fill()
    • comparaison de std::unitialized_copy() avec std::copy()
    • les std::raw_storage_iterator (ou, du moins, ce que ceux-ci auraient dû être, ce type étant déprécié depuis C++ 17)
    • nouveaux algorithmes avec C++ 17, proposés par SG14 :
      • std::uninitialized_default_construct()
      • std::uninitialized_value_construct()
      • std::destroy()
  • Opérations modifiant la structure d'un tel conteneur (insert(), erase()) : subtilités et enjeux
  • Introduction aux allocateurs depuis C++ 11
  • Introduction aux allocateurs pmr de C++ 17
• Introduction aux problèmes d'entrées/ sorties dans les STR (sujet sur lequel nous reviendrons) :
  • entrées ininterruptibles (TR strict)
  • contrainte d'immédiateté (basse latence)
  • contrainte de brièveté
  • combiner indéterminisme des entrées/ sorties et consommation de données à rythme constant
  • distinguer temps constant et temps constant amorti (quand cela compte)
  • réduire le blocage

Au menu :

• Q04
• Q05
• Retour sur le dossier de la gestion de l'allocation dynamique de mémoire :
  • Implémenter un conteneur tirant profit des mécanismes distinguant allocation et initialisation
  • Rédiger un conteneur générique du calibre de std::vector, donc générique, robuste et rapide
    • sans allocateur
    • avec allocateur
  • Algorithmes standards sur de la mémoire brute et différences avec algorithmes standards usuels
    • comparaison de std::unitialized_fill() avec std::fill()
    • comparaison de std::unitialized_copy() avec std::copy()
    • les std::raw_storage_iterator (ou, du moins, ce que ceux-ci auraient dû être, ce type étant déprécié depuis C++ 17)
    • nouveaux algorithmes avec C++ 17, proposés par SG14 :
      • std::uninitialized_default_construct()
      • std::uninitialized_value_construct()
      • std::destroy()
  • Opérations modifiant la structure d'un tel conteneur (insert(), erase()) : subtilités et enjeux
  • Introduction aux allocateurs depuis C++ 11
  • Introduction aux allocateurs pmr de C++ 17
• Introduction aux problèmes d'entrées/ sorties dans les STR (sujet sur lequel nous reviendrons) :
  • entrées ininterruptibles (TR strict)
  • contrainte d'immédiateté (basse latence)
  • contrainte de brièveté
  • combiner indéterminisme des entrées/ sorties et consommation de données à rythme constant
  • distinguer temps constant et temps constant amorti (quand cela compte)
  • réduire le blocage

Au menu :

• Q06
• Retour sur Q04 (incluant les coûts du passage par une vtbl, de même que ceci et cela)
• Retour sur Q05 (c'est parfois subtil, la vie.. Voir en particulier https://eel.is/c++draft/basic.memobj et https://eel.is/c++draft/basic.memobj#intro.object-13)
• Examen d'une stratégie interruptible de compression de données, incluant :
  • le concept général de fonction morcelable (une espèce de fonction interruptible_foreach())
• Références de relais et Perfect Forwarding
  • construction et fabrication par emplacement
• Parenthèse sur les union, particulièrement les union étiquetés
• Alternative aux exceptions (entre autres choses) : implémenter un maybe<T>

Au menu :

• Q06
• Retour sur Q04 (incluant les coûts du passage par une vtbl, de même que ceci et cela)
• Retour sur Q05 (c'est parfois subtil, la vie.. Voir en particulier https://eel.is/c++draft/basic.memobj et https://eel.is/c++draft/basic.memobj#intro.object-13)
• Examen d'une stratégie interruptible de compression de données, incluant :
  • le concept général de fonction morcelable (une espèce de fonction interruptible_foreach())
• Références de relais et Perfect Forwarding
  • construction et fabrication par emplacement
• Parenthèse sur les union, particulièrement les union étiquetés
• Alternative aux exceptions (entre autres choses) : implémenter un maybe<T>

Au menu :

• Q07
• La spécification RTSJ pour Java TR
• Quelques modèles architecturaux de STR :
  • les exécutifs
  • entrées / sorties et TR strict
• AoS ou SoA
  • ce que ça signifie
  • conséquences
• Premier contact avec un SETR, soit QNX Neutrino
  • mécanismes de messagerie
  • inversion de priorités
  • héritage de priorité
  • ordonnanceurs inéquitables

Au menu :

• Q07
• La spécification RTSJ pour Java TR
• Quelques modèles architecturaux de STR :
  • les exécutifs
  • entrées / sorties et TR strict
• AoS ou SoA
  • ce que ça signifie
  • conséquences
• Premier contact avec un SETR, soit QNX Neutrino
  • mécanismes de messagerie
  • inversion de priorités
  • héritage de priorité
  • ordonnanceurs inéquitables

Au menu :

• Présentations de projets :
  • Antoine Yapeti et Cédric Laliberté : « Présentation du KwoiiiBoard »
• Q09 (car Q08 est les présentations des projets, pour celles et ceux qui le font)
• Collecte d'ordures et STR : exemple concret de Metronome
  • voir ../../Liens/Temps-Reel--Liens.html#metronome pour des détails

Il existe d'autres langages accompagnés de moteurs de collecte d'ordures visant à réduire la latence plutôt qu'à accroître le débit. Par exemple, certains usagers du langage Go rapportent des pauses maximales de l'ordre de 7,1 ms, ce qui peut être acceptable pour certains STR (probablement pas pour du TR strict, cependant, comme l'indique aussi ceci)

• Ordonnanceurs périodiques
  • On parle ici du type d'ordonnanceur qui sied dans un contexte ciblé ou l'ensemble des tâches est fini et fermé
  • Tâches périodiques, apériodiques et sporadiques
• Familles de stratégies d'ordonnancement
  • Algorithmes à priorité fixe (FPS, Fixed Priority Scheduling)
    • RMS (Rate Monotonic Scheduling)
    • DMPO (Deadline Monotonic Priority Scheduling)
  • Algorithmes à priorité dynamique (DPS, Dynamic Priority Scheduling)
    • EDF (Earliest Deadline First)
  • Algorithmes basés sur la valeur relative de la tâche (VBS, Value-Based Scheduling)
• Temps de réponse d'une tâche ou d'un système
• Ordonnanceurs pris dans une acception plus large. Liste non-exhaustive :
  • Approche FIFO
  • Approche Round-Robin
  • Approche adaptative (plusieurs saveurs sont possibles)
  • Approche sporadique
  • Approche par partitions
• Tests « d'ordonnançabilité » :
  • Notation
  • Quelques exemples
• Algorithmes Data-Invariant
• Algorithmes Cache-Oblivious

Si le temps le permet :

• Utiliser les traits à fins de conception de programmes plus robustes : conversions de référentiels
• Survol de std::variant (amorce)

#include <type_traits>
using namespace std;

/*
template <class T, T val> struct integral_constant {
   using type = T;
   static constexpr type value = val;
   constexpr auto operator()() const noexcept { return value; }
};
template <bool B> struct bool_constant : integral_constant<bool, B> {};
struct true_type : bool_constant<true> {};
struct false_type : bool_constant<false> {};
*/

template <auto V> struct constant {
   using type = decltype(V);
   static constexpr type value = V;
   constexpr auto operator()() const noexcept { return value; }
};

template <class ...>
   struct type_list;

using flottants = type_list<float, double, long double>;

template <class> struct longueur;
template <class T, class ... Q> struct longueur<type_list<T, Q...>> {
   enum { value = 1 + longueur<type_list<Q...>>::value };
};
template <> struct longueur<type_list<>> {
   enum { value = 0 };
};

template <int N> struct int_ : constant<N> {};


template <class T, class U>
   struct somme_ : int_<T::value + U::value> {};
template <class T, class U>
   struct produit_ : int_<T::value * U::value> {};

template <class TL, template <class, class> class F, class Init>
   struct cumuler;
template <class T, class ... Q, template <class, class> class F, class Init>
   struct cumuler<type_list<T, Q...>, F, Init>
      : F<T, cumuler<type_list<Q...>, F, Init>> {
   };
template <template <class, class> class F, class Init>
   struct cumuler<type_list<>, F, Init> : Init {
   };

template <class TL> using somme = cumuler<TL, somme_, int_<0>>;
template <class TL> using produit = cumuler<TL, produit_, int_<1>>;

//
//template <class> struct somme;
//template <class T, class ... Q>
//   struct somme<type_list<T, Q...>>
//      : int_<T::value + somme<type_list<Q...>>::value> {
//   };
//template <> struct somme <type_list<>> : int_<0> {};
//
//template <class> struct produit;
//template <class T, class ... Q>
//struct produit<type_list<T, Q...>>
//   : int_<T::value * produit<type_list<Q...>>::value> {
//};
//template <> struct produit <type_list<>> : int_<1> {};

int main() {
   using prems = type_list<int_<2>, int_<3>, int_<5>, int_<7>, int_<11>>;
   static_assert(somme<prems>::value == 28);
   static_assert(produit<prems>::value == 2310);

   using trois = integral_constant<int, 3>;
   static_assert(trois{}() == 3);
   static_assert(longueur<flottants>::value == 3);
}

Au menu :

• Q09 (car Q08 est les présentations des projets, S11)
• Collecte d'ordures et STR : exemple concret de Metronome
  • voir ../../Liens/Temps-Reel--Liens.html#metronome pour des détails

Il existe d'autres langages accompagnés de moteurs de collecte d'ordures visant à réduire la latence plutôt qu'à accroître le débit. Par exemple, certains usagers du langage Go rapportent des pauses maximales de l'ordre de 7,1 ms, ce qui peut être acceptable pour certains STR (probablement pas pour du TR strict, cependant, comme l'indique aussi ceci)

• Ordonnanceurs périodiques
  • On parle ici du type d'ordonnanceur qui sied dans un contexte ciblé ou l'ensemble des tâches est fini et fermé
  • Tâches périodiques, apériodiques et sporadiques
• Familles de stratégies d'ordonnancement
  • Algorithmes à priorité fixe (FPS, Fixed Priority Scheduling)
    • RMS (Rate Monotonic Scheduling)
    • DMPO (Deadline Monotonic Priority Scheduling)
  • Algorithmes à priorité dynamique (DPS, Dynamic Priority Scheduling)
    • EDF (Earliest Deadline First)
  • Algorithmes basés sur la valeur relative de la tâche (VBS, Value-Based Scheduling)
• Temps de réponse d'une tâche ou d'un système
• Ordonnanceurs pris dans une acception plus large. Liste non-exhaustive :
  • Approche FIFO
  • Approche Round-Robin
  • Approche adaptative (plusieurs saveurs sont possibles)
  • Approche sporadique
  • Approche par partitions
• Tests « d'ordonnançabilité » :
  • Notation
  • Quelques exemples
• Algorithmes Data-Invariant
• Algorithmes Cache-Oblivious

Si le temps le permet :

• Utiliser les traits à fins de conception de programmes plus robustes : conversions de référentiels
• Survol de std::variant

Toujours si le temps le permet, pour vous divertir :

• SSO et SOO
  • ce que ça signifie
  • implémentations possibles (voir sso_string.h et sso_test.cpp)
  • discussion des enjeux
• Programmer à coût zéro à l'exécution (sorte de cadeau non-Haskell – désolé! – mais destiné aux Haskelliennes et les Haskelliens parmi vous) :
  • listes de types
  • transformer des constantes en types
  • raisonner sur des types
  • voir ../../Sujets/Divers--cplusplus/Metaprogrammation.html et ../../Sources/static_exemples.html pour des détails

#include <type_traits>
using namespace std;

/*
template <class T, T val> struct integral_constant {
   using type = T;
   static constexpr type value = val;
   constexpr auto operator()() const noexcept { return value; }
};
template <bool B> struct bool_constant : integral_constant<bool, B> {};
struct true_type : bool_constant<true> {};
struct false_type : bool_constant<false> {};
*/

template <auto V> struct constant {
   using type = decltype(V);
   static constexpr type value = V;
   constexpr auto operator()() const noexcept { return value; }
};

template <class ...>
   struct type_list;

using flottants = type_list<float, double, long double>;

template <class> struct longueur;
template <class T, class ... Q> struct longueur<type_list<T, Q...>> {
   enum { value = 1 + longueur<type_list<Q...>>::value };
};
template <> struct longueur<type_list<>> {
   enum { value = 0 };
};

template <int N> struct int_ : constant<N> {};


template <class T, class U>
   struct somme_ : int_<T::value + U::value> {};
template <class T, class U>
   struct produit_ : int_<T::value * U::value> {};

template <class TL, template <class, class> class F, class Init>
   struct cumuler;
template <class T, class ... Q, template <class, class> class F, class Init>
   struct cumuler<type_list<T, Q...>, F, Init>
      : F<T, cumuler<type_list<Q...>, F, Init>> {
   };
template <template <class, class> class F, class Init>
   struct cumuler<type_list<>, F, Init> : Init {
   };

template <class TL> using somme = cumuler<TL, somme_, int_<0>>;
template <class TL> using produit = cumuler<TL, produit_, int_<1>>;

//
//template <class> struct somme;
//template <class T, class ... Q>
//   struct somme<type_list<T, Q...>>
//      : int_<T::value + somme<type_list<Q...>>::value> {
//   };
//template <> struct somme <type_list<>> : int_<0> {};
//
//template <class> struct produit;
//template <class T, class ... Q>
//struct produit<type_list<T, Q...>>
//   : int_<T::value * produit<type_list<Q...>>::value> {
//};
//template <> struct produit <type_list<>> : int_<1> {};

int main() {
   using prems = type_list<int_<2>, int_<3>, int_<5>, int_<7>, int_<11>>;
   static_assert(somme<prems>::value == 28);
   static_assert(produit<prems>::value == 2310);

   using trois = integral_constant<int, 3>;
   static_assert(trois{}() == 3);
   static_assert(longueur<flottants>::value == 3);
}

Au menu :

• Présentations de projets :
  • Alexandre Ehrhard, Loïs Montessuit, Sophie Trouillot et Karl Plourde : « Version numérique immersive de la Coinche »
  • Hermann Ngandeu Ngotcho, « IDS from scratch »
  • Vincent Beaudoin et Mikael Demers, « Equalizer portable »

Si le temps le permet :

• Utiliser les traits à fins de conception de programmes plus robustes : conversions de référentiels
• Survol de std::variant (suite)

Toujours si le temps le permet, pour vous divertir :

• SSO et SOO
  • ce que ça signifie
  • implémentations possibles (voir sso_string.h et sso_test.cpp)
  • discussion des enjeux
• Programmer à coût zéro à l'exécution (sorte de cadeau non-Haskell – désolé! – mais destiné aux Haskelliennes et les Haskelliens parmi vous) :
  • listes de types
  • transformer des constantes en types
  • raisonner sur des types
  • voir ../../Sujets/Divers--cplusplus/Metaprogrammation.html et ../../Sources/static_exemples.html pour des détails

#include <type_traits>
using namespace std;

/*
template <class T, T val> struct integral_constant {
   using type = T;
   static constexpr type value = val;
   constexpr auto operator()() const noexcept { return value; }
};
template <bool B> struct bool_constant : integral_constant<bool, B> {};
struct true_type : bool_constant<true> {};
struct false_type : bool_constant<false> {};
*/

template <auto V> struct constant {
   using type = decltype(V);
   static constexpr type value = V;
   constexpr auto operator()() const noexcept { return value; }
};

template <class ...>
   struct type_list;

using flottants = type_list<float, double, long double>;

template <class> struct longueur;
template <class T, class ... Q> struct longueur<type_list<T, Q...>> {
   enum { value = 1 + longueur<type_list<Q...>>::value };
};
template <> struct longueur<type_list<>> {
   enum { value = 0 };
};

template <int N> struct int_ : constant<N> {};


template <class T, class U>
   struct somme_ : int_<T::value + U::value> {};
template <class T, class U>
   struct produit_ : int_<T::value * U::value> {};

template <class TL, template <class, class> class F, class Init>
   struct cumuler;
template <class T, class ... Q, template <class, class> class F, class Init>
   struct cumuler<type_list<T, Q...>, F, Init>
      : F<T, cumuler<type_list<Q...>, F, Init>> {
   };
template <template <class, class> class F, class Init>
   struct cumuler<type_list<>, F, Init> : Init {
   };

template <class TL> using somme = cumuler<TL, somme_, int_<0>>;
template <class TL> using produit = cumuler<TL, produit_, int_<1>>;

//
//template <class> struct somme;
//template <class T, class ... Q>
//   struct somme<type_list<T, Q...>>
//      : int_<T::value + somme<type_list<Q...>>::value> {
//   };
//template <> struct somme <type_list<>> : int_<0> {};
//
//template <class> struct produit;
//template <class T, class ... Q>
//struct produit<type_list<T, Q...>>
//   : int_<T::value * produit<type_list<Q...>>::value> {
//};
//template <> struct produit <type_list<>> : int_<1> {};

int main() {
   using prems = type_list<int_<2>, int_<3>, int_<5>, int_<7>, int_<11>>;
   static_assert(somme<prems>::value == 28);
   static_assert(produit<prems>::value == 2310);

   using trois = integral_constant<int, 3>;
   static_assert(trois{}() == 3);
   static_assert(longueur<flottants>::value == 3);
}

Au menu :

• Séance où vous présenterez vos projets de session. Si ce n'est pas terminé, c'est pas dramatique, mais on veut qu'il y ait une réflexion et une analyse derrière ce qui sera présenté
• La séance débutera par une présentation de David Viens, spécialiste de l'audio temps réel et l'un des principaux artisans derrière Plogue Arts et Technologie : https://www.plogue.com/

Cliquez sur cette cible pour obtenir le code de la chaîne pascal simplifiée

Cliquez sur cette cible pour obtenir le code de la chaîne pascal avec itérateurs

Cliquez sur cette cible pour obtenir le code du test 0.0

Cliquez sur cette cible pour obtenir le code du test 0.0b

Cliquez sur cette cible pour obtenir le code du test 0.1

Cliquez sur cette cible pour obtenir le code du test 1.0

Cliquez sur cette cible pour obtenir le code du test 1.1

Cliquez sur cette cible pour obtenir le code du test 1.2

Cliquez sur cette cible pour obtenir le code du test 1.3

Cliquez sur cette cible pour obtenir le code du test 2.0

Cliquez sur cette cible pour obtenir le code du test 2.1

Cliquez sur cette cible pour obtenir le code du test 2.2

Cliquez sur cette cible pour obtenir le code du test 3.0

Cliquez sur cette cible pour obtenir le projet bmp00, réalisant une compression RLE sur des bitmaps dans un temps raisonnable. Ce projet n'est pas un STR puisqu'il cherche à réaliser rapidement et correctement une tâche mais n'offre aucune garantie de non-dépassement d'un seuil de temps – il n'y a aucun plafond mesurable dans le temps d'exécution de l'algorithme de compression dans ce programme, donc aucune contrainte de temps dont le respect serait déterministe.

L'idée d'offrir d'abord une version opérationnelle d'un algorithme donné, sans se préoccuper de contraintes TR, est que cette version est en général plus simple que les versions offrant des garanties TR strictes.

Cliquez sur cette cible pour obtenir le projet bmp_morcele, réalisant une compression RLE sur des bitmaps dans un temps raisonnable et de manière à ne pas dépasser un certain seuil de tolérance au temps.

Cette version compresse des données RGB brutes selon une approche RLE et peut, contrairement aux deux précédentes, être considérée TR (au sens usuel, pas au sens strict, mais principalement à cause de la plateforme) dans la mesure où le seuil indiquant d'arrêter tiendrait compte du pire cas possible (calculé a priori) pour une séquence de compression RLE donnée. Aller jusque là demanderait toutefois une meilleure connaissance du contexte et obscurcirait quelque peu le propos. Le code du projet est du code de test, montrant qu'il est possible de faire en sorte que l'algorithme de compression s'interrompe « en cours de traitement ».

Cliquez sur cette cible pour la description du format bitmap.

Cliquez sur cette cible pour la description de la compression RLE. Pour un peu de pédagogie sur RLE, voir http://hbfs.wordpress.com/2009/04/14/ad-hoc-compression-methods-rle/

Pour un texte sur le concept, voir ../../Sujets/TempsReel/executifs.html

Cliquez sur cette cible pour obtenir les sources d'un projet contenant une ébauche fonctionnelle d'exécutif de simulation. Ce projet a été conçu avec Visual Studio 2022, mais les sources sont essentiellement portables (le fichier source non portable est concis, et je pense que vous n'aurez pas de peine à l'identifier).

Un exécutif est un système monoprogrammé qui, avec discipline et avec soin, permet d'atteindre des performances prévisibles et des comportements se rapprochant de ceux qu'on retrouve dans les systèmes multiprogrammés, mais sans payer le prix associés outils de synchronisation. Rien n'est parfait (la mécanique ne peut être répartie sur plusieurs coeurs qu'au prix d'efforts manuels) mais l'idée peut être stimulante et repose sur des techniques qu'on enseigne peu à dans nos institutions aujourd'hui.