| Séances
IFT611/729 |
Contenu
IFT611/729 |
Séances INF749 |
Contenu INF749 |
| S00 –
IFT611/729, 9 janvier |
Le mots de la semaine : introduction,
vocabulaire et bases. On s'entend sur
quelques termes et façons de faire qui nous suivront toute la session 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 d'éléments de vocabulaire
- 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
Petit complément : j'ai rédigé
un petit comparatif de « performances » pour certaines opérations types
applicables à un tableau brut, alloué dynamiquement, et
à un vecteur standard.
Il s'avère que, lorsqu'il est bien utilisé,
le vecteur est presque toujours aussi rapide – ou plus rapide! –
que son substrat, le tableau brut, parce que le code sous-jacent est extrêmement
sophistiqué et parce que nous, programmeurs de tous les jours, ne prenons pas chaque fois le soin de manipuler nos tableaux comme le font en tout temps les concepteurs du vecteur standard.
Le dire, bien sûr, c'est une chose, mais le démontrer,
c'est mieux, alors jetez un coup d'oeil à ../../Sources/comparatif_vecteur_tableau.html si vous êtes intéressé(e).
De même, si vous êtes curieuse / curieux de comparer la vitesse à
l'exécution d'une fonction et d'un foncteur
à tâche équivalente, voir
../../Sources/Comparaison-Fonctions-Foncteurs.html
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).
Truc important : bien que je ne l'aie pas mentionné
explicitement pendant la séance, ce cours mettra l'accent sur plusieurs
facettes de la conception et du développement de STR, dont :
- Le respect en tout temps des contraintes fixées
a priori.. Nous en avons
discuté quelque peu en classe (itérer à rythme régulier ou constant,
s'exécuter de manière brève, démarrer immédiatement – faible latence)
- La
résilience. Un STR étant fréquemment un
système dont dépend l'intégrité des gens et du matériel, sa
résilience
tend à être une caractéristique plus que souhaitable
- La concision. étant souvent destinés à opérer des systèmes embarqués ou
à s'exécuter sur du matériel plus... humble, mais aux caractéristiques
d'exécution plus prévisibles que ne le sont celles du matériel très
sophistiqué mis à notre disposition aujourd'hui, il n'est pas rare
qu'un STR doive occuper un espace réduit en mémoire
Ne vous étonnez donc pas de voir ces thématiques apparaître de manière
récurrente dans notre discours. |
S00 – INF749,
10 janvier |
Le mots de la semaine : introduction,
vocabulaire et bases. On s'entend sur
quelques termes et façons de faire qui nous suivront toute la session 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 d'éléments de vocabulaire
- 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())
- J'ai remis les
λ-expression
au prochain cours car il se fait tard
- Bref
comparatif de programmes bloquant et non-bloquant
- Bref
comparatif de programmes avec tâche s'exécutant à rythme régulier et à
rythme constant
Petit complément : j'ai rédigé
un petit comparatif de « performances » pour certaines opérations types
applicables à un tableau brut, alloué dynamiquement, et
à un vecteur standard.
Il s'avère que, lorsqu'il est bien utilisé,
le vecteur est presque toujours aussi rapide – ou plus rapide! –
que son substrat, le tableau brut, parce que le code sous-jacent est extrêmement
sophistiqué et parce que nous, programmeurs de tous les jours, ne prenons pas chaque fois le soin de manipuler nos tableaux comme le font en tout temps les concepteurs du vecteur standard.
Le dire, bien sûr, c'est une chose, mais le démontrer,
c'est mieux, alors jetez un coup d'oeil à ../../Sources/comparatif_vecteur_tableau.html si vous êtes intéressé(e).
De même, si vous êtes curieuse / curieux de comparer la vitesse à
l'exécution d'une fonction et d'un foncteur
à tâche équivalente, voir
../../Sources/Comparaison-Fonctions-Foncteurs.html
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).
Truc important : bien que je ne l'aie pas mentionné
explicitement pendant la séance, ce cours mettra l'accent sur plusieurs
facettes de la conception et du développement de STR, dont :
- Le respect en tout temps des contraintes fixées
a priori.. Nous en avons
discuté quelque peu en classe (itérer à rythme régulier ou constant,
s'exécuter de manière brève, démarrer immédiatement – faible latence)
- La
résilience. Un STR étant fréquemment un
système dont dépend l'intégrité des gens et du matériel, sa
résilience
tend à être une caractéristique plus que souhaitable
- La concision. étant souvent destinés à opérer des systèmes embarqués ou
à s'exécuter sur du matériel plus... humble, mais aux caractéristiques
d'exécution plus prévisibles que ne le sont celles du matériel très
sophistiqué mis à notre disposition aujourd'hui, il n'est pas rare
qu'un STR doive occuper un espace réduit en mémoire
Ne vous étonnez donc pas de voir ces thématiques apparaître de manière
récurrente dans notre discours. |
| S01 –
IFT611/729, 16 janvier |
Le mots de la semaine : saines
pratiques et hygiène de programmation. On
établit des façons de faire, et on examine les nuances entre copie
(complexité typiquement linéaire, temps souvent indéterministe) et
mouvement (complexité typiquement constante, temps souvent déterministe),
tout en introduisant quelques
idiomes fort utiles. Au menu, d'une manière teintée par notre besoin d'avoir
une approche appropriée pour le développement de STR :
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
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.
Le code utilisé pour la classe Tableau suit
(notez que nous discuterons de
[[nodiscard]], de push_back(), de
grow() et des
deux déclinaisons de operator[] à la séance
S02) :
#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.
|
S01 – INF749,
17 janvier |
Le mots de la semaine : saines
pratiques et hygiène de programmation. On
établit des façons de faire, et on examine les nuances entre copie
(complexité typiquement linéaire, temps souvent indéterministe) et
mouvement (complexité typiquement constante, temps souvent déterministe),
tout en introduisant quelques
idiomes fort utiles. Au menu, d'une manière teintée par notre besoin d'avoir
une approche appropriée pour le développement de STR :
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
-
Opérateurs d'égalité (==,
!=)
-
Sémantique de mouvement
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.
Le code utilisé pour la classe Tableau suit
(notez que nous discuterons de
[[nodiscard]], de push_back() et de
grow() à la séance
S02) :
#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.
|
|
S02 – IFT611/729,
23 janvier |
Le mots de la semaine :
sélection à coût nul d'algorithmes. Premier contact avec les traits
et leurs applications. Au menu :
- Q00
- Compléter l'implémentation du tableau d'entiers débuté à
S01 :
-
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
-
Opérateurs d'égalité (==,
!=)
-
Sémantique de mouvement
- Comprendre le
mouvement
à l'aide d'une classe
Noisy
La classe Tableau avec constructeur et
affectation de mouvement suit, et il en va de même pour le test qui met
en relief l'impact du
mouvement sur la vitesse d'un programme :
#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 {
if (this == &autre) return *this;
delete[] elems;
elems = std::exchange(autre.elems, nullptr);
nelems = std::exchange(autre.nelems, 0);
cap = std::exchange(autre.cap, 0);
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).count()
<< " us." << endl;
cout << "g(v) : " << duration_cast<microseconds>(dt1).count()
<< " us." << endl;
cout << "v = f(std::move(v)) : " << duration_cast<microseconds>(dt2).count()
<< " us." << endl;
}
Notez que notre examen d'implémentations génériques d'un tableau
suivra sous peu; nous avons quelques menus détails à explorer auparavant. 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.
Attention : séance à distance, exceptionnellement |
S02 – INF749,
24 janvier |
Le mots de la semaine :
sélection à coût nul d'algorithmes. Premier contact avec les traits
et leurs applications. Au menu :
- Q00
- Compléter l'implémentation du tableau d'entiers débuté à
S01 :
-
La méthode push_back() et
l'implémentation d'un algorithme de croissance
- Comprendre le
mouvement
à l'aide d'une classe
Noisy
La classe Tableau avec constructeur et
affectation de mouvement suit, et il en va de même pour le test qui met
en relief l'impact du
mouvement sur la vitesse d'un programme :
#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 {
if (this == &autre) return *this;
delete[] elems;
elems = std::exchange(autre.elems, nullptr);
nelems = std::exchange(autre.nelems, 0);
cap = std::exchange(autre.cap, 0);
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).count()
<< " us." << endl;
cout << "g(v) : " << duration_cast<microseconds>(dt1).count()
<< " us." << endl;
cout << "v = f(std::move(v)) : " << duration_cast<microseconds>(dt2).count()
<< " us." << endl;
}
Notez que notre examen d'implémentations génériques d'un tableau
suivra sous peu; nous avons quelques menus détails à explorer auparavant.
La fonction
distance() est un cas
d'espèce intéressant, tiré du standard lui-même,
qui exploite les traits et les catégories pour réaliser
une optimisation presque obscène. J'aime bien faire le tour de
cette approche, qui peut être appliquée à bien d'autres
trucs, avec des gens qui, comme vous, doivent écrire des programmes
dont les performances sont sans compromis.
Les plus curieuses et les plus curieux remarqueront que les fonctions
advance(),
next()
et
prev()
appliquent les mêmes techniques d'optimisation que sa cousine
distance().
J'ai utilisé la technique du tag dispatching, mais il existe
d'autres techniques pour y arriver :
#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{}
);
}
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.
|
| S03 –
IFT611/729,
30 janvier |
Le mots de la semaine :
sélection à coût nul d'algorithmes et résilience.
Notre exploration des traits
et de leurs applications se poursuit; nous revenons sur le tableau
d'entiers pour en faire un tableau générique, et nous examinons les
conséquences de ce geste sur la résilience de notre code.
- Q01
- 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
- 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.
La fonction
distance() est un cas
d'espèce intéressant, tiré du standard lui-même,
qui exploite les traits et les catégories pour réaliser
une optimisation presque obscène. J'aime bien faire le tour de
cette approche, qui peut être appliquée à bien d'autres
trucs, avec des gens qui, comme vous, doivent écrire des programmes
dont les performances sont sans compromis.
Les plus curieuses et les plus curieux remarqueront que les fonctions
advance(),
next()
et
prev()
appliquent les mêmes techniques d'optimisation que sa cousine
distance().
J'ai utilisé la technique du tag dispatching, mais il existe
d'autres techniques pour y arriver :
#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{}
);
}
N'oubliez pas de livrer L00
aujourd'hui! |
S03 – INF749,
31 janvier |
Le mots de la semaine :
sélection à coût nul d'algorithmes et résilience.
Notre exploration des traits
et de leurs applications se poursuit; nous revenons sur le tableau
d'entiers pour en faire un tableau générique, et nous examinons les
conséquences de ce geste sur la résilience de notre code. 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.
N'oubliez pas de livrer L00
aujourd'hui! |
|
IFT611/729, 6 février |
Je serai absent ce matin dû à une rencontre du
WG21 à Issaquah. La séance aura tout de même lieu (ultérieurement,
à une plage horaire qui reste à déterminer, et à distance). Vous pourrez
suivre mes aventures sur
../../Sujets/Orthogonal/wg21-2023-Issaquah.html
|
INF749,
7 février |
Étant donné que nous sommes un petit groupe qui progresse rapidement, vous
aurez congé cette semaine car je serai absent ce matin dû à une rencontre
du WG21
à Issaquah. Vous pourrez suivre mes aventures sur ../../Sujets/Orthogonal/wg21-2023-Issaquah.html
|
| S04 –
IFT611/729, 13 février |
Le mots de la semaine : gestion
déterministe des ressources. Dans les
STR,
traditionnellement, l'allocation de ressources (mémoire et autres) tend à
être reléguée au rang des opérations indéterministes en temps, à juste
titre, donc devant être réalisées a priori, n'étant pas à propos pour les
tronçons assujettis à des contraintes
TR.
Cependant, lorsque nous
connaissons le contexte, il est parfois possible de faire de petits
miracles. Au menu :
Pour le code du tableau générique tel que vu en classe, voici :
#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;
}
};
Pour le code (plus simple, tout aussi efficace) que l'on obtient si on ajoute un
unique_ptr
à notre tableau générique,
voici :
#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
L'optique poursuivie est :
- Explorer la question de la
résilience des programmes plus en
détail
- Voir comment il est possible de contrôler finement les mécanismes
d'allocation (choisir le lieu, la façon, les stratégies, etc.)
- Montrer comment il est possible d'en arriver à des mécanismes
d'allocation dynamique de mémoire qui soient déterministes (quand le
contexte s'y prête)
|
S04 – INF749,
14 février |
Le mots de la semaine : gestion
déterministe des ressources. Dans les
STR,
traditionnellement, l'allocation de ressources (mémoire et autres) tend à
être reléguée au rang des opérations indéterministes en temps, à juste
titre, donc devant être réalisées a priori, n'étant pas à propos pour les
tronçons assujettis à des contraintes
TR.
Cependant, lorsque nous
connaissons le contexte, il est parfois possible de faire de petits
miracles. Au menu :
Pour le code du tableau générique tel que vu en classe, voici :
#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;
}
};
Pour le code (plus simple, tout aussi efficace) que l'on obtient si on ajoute un
unique_ptr
à notre tableau générique,
voici :
#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
L'optique poursuivie est :
- Explorer la question de la
résilience des programmes plus en
détail
- Voir comment il est possible de contrôler finement les mécanismes
d'allocation (choisir le lieu, la façon, les stratégies, etc.)
- Montrer comment il est possible d'en arriver à des mécanismes
d'allocation dynamique de mémoire qui soient déterministes (quand le
contexte s'y prête)
|
| S05 –
IFT611/729, 20 février |
Au menu :
Pour le code (plus simple, tout aussi efficace) que l'on obtient si on ajoute un
unique_ptr
à notre tableau générique,
voici :
#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
L'optique poursuivie est :
- Explorer la question de la
résilience des programmes plus en
détail
- Voir comment il est possible de contrôler finement les mécanismes
d'allocation (choisir le lieu, la façon, les stratégies, etc.)
- Montrer comment il est possible d'en arriver à des mécanismes
d'allocation dynamique de mémoire qui soient déterministes (quand le
contexte s'y prête)
|
S05 – INF749,
21 février |
Au menu :
- Q03
- Premiers pas dans la gestion intelligente de la mémoire (rappel) :
- 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
- nous reviendrons (une dernière fois) sur cette question la
semaine prochaine en complétant notre aventure visant à mettre en
place un tableau du calibre de std::vector
- cette semaine, on s'amuse un peu!
- Retour sur Q02, en particulier :
- Introduction de
constexpr
-
Littéraux maison
- Petit tour amusant du côté des
templates variadiques
- Quelques mots sur les
Fold Expressions
Le mots de la semaine :
abstractions à coût nul, ou comment exprimer des solutions
générales et efficace sans que cela n'entraîne quelque coût que ce soit à
l'exécution.
|
| 27
février |
Relâche au campus principal. Reposez-vous un peu, vous en avez sûrement
besoin!
|
S06 – INF749,
28 février |
Au menu :
- 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
- Algorithmes standards sur de la mémoire brute et différences avec
algorithmes standards usuels
- 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
- Suite de la discussion sommaire sur les
pointeurs intelligents (voir
smart_ptr.pdf pour la présentation
électronique sur le sujet)
|
| S06
– IFT611/729,
6
mars |
Au menu :
Le mots de la semaine :
abstractions à coût nul, ou comment exprimer des solutions
générales et efficace sans que cela n'entraîne quelque coût que ce soit à
l'exécution.
|
S07 – INF749,
7 mars |
Au menu :
- Q04
- Retour sur Q03, en particulier :
- La question du
comportement indéfini, ou « pourquoi "ça marche
pourtant" n'est ni rassurant, ni suffisant »
- Comment on aurait pu se simplifier la vie en lisant la documentation
(ou : le prof n'est pas gentil avec nous)
- 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
- L'enjeu du faux
partage
- Si le temps le permet, on amorcera l'examen d'une stratégie
interruptible de compression de données
|
|
S07 – IFT611/729, 13 mars |
Au menu :
- Q04
- Retour sur Q03, en particulier :
- La question du
comportement indéfini, ou « pourquoi "ça marche
pourtant" n'est ni rassurant, ni suffisant »
- Comment on aurait pu se simplifier la vie en lisant la documentation
(ou : le prof n'est pas gentil avec nous)
- 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
- Algorithmes standards sur de la mémoire brute et différences avec
algorithmes standards usuels
- 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
- Suite de la discussion sommaire sur les
pointeurs intelligents (voir
smart_ptr.pdf pour la présentation
électronique sur le sujet)
|
S08 – INF749,
14 mars |
Au menu :
|
|
S08 –
IFT611/729, 20 mars |
Au menu :
- Q05
- Retour sur Q04
- 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
- L'enjeu du faux
partage
- Si le temps le permet, on amorcera l'examen d'une stratégie
interruptible de compression de données
|
S09 – INF749,
21 mars |
Au menu :
|
| S09 –
IFT611/729, 27 mars |
Au menu :
|
S10 – INF749,
28 mars |
Au menu :
|
| S10 –
IFT611/729, 3 avril |
Au menu :
|
S11 – INF749,
4 avril |
Au menu :
Si le temps le permet, pour vous divertir :
- Programmer à coût zéro à l'exécution (sorte de cadeau non-Haskell – désolé! – mais destiné aux
Haskelliennes et les Haskelliens parmi vous) :
N'oubliez pas de livrer L02
aujourd'hui! |
|
10 avril |
Lundi de Pâques
|
S12 – INF749,
11 avril |
Au menu :
- Q09
- Séance où vous présenterez vos projets de session (si c'est pas
terminé, c'est pas dramatique, mais on veut qu'il y ait une réflexion et
une analyse derrière)
- 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/
|
| S11 –
IFT611/729,
17 avril |
Au menu :
Si le temps le permet, pour vous divertir :
-
SSO
et SOO
- Programmer à coût zéro à l'exécution (sorte de cadeau non-Haskell – désolé! – mais destiné aux
Haskelliennes et les Haskelliens parmi vous) :
N'oubliez pas de livrer L02
aujourd'hui! |
S13 – INF749,
18 avril |
Chic examen final plein d'amour
|
|
S12 –
IFT611/729,
28 avril |
Chic examen final plein d'amour, de 9h à
12h au D3-2029
|
|
|
Les sections qui suivent proposent du code ou des exemples proposés
en classe, le tout dans le but de vous permettre d'étudier la chose,
de critiquer, de commenter, de questionner et d'expérimenter à
loisir. Notez que certains des exemples ci-dessous doivent être retouchés
à la lueur de l'avènement du standard C++ 11.
Un appareil de type « photo radar » a pour rôle de
détecter le mouvement d'un véhicule dans un espace contrôlé et, si la vitesse
de déplacement du véhicule en question dépasse un certain seuil, de provoquer
une capture d'image qui sera analysée pour détecter un ensemble de
caractéristiques (couleur, marque, symboles sur la plaque d'immatriculation,
etc.).
En bref, un capteur physique (le radar) saisit les mouvements d'objets dans un espace et les signale à un module d'analyse de première ligne capable de reconnaître un déplacement suspect et de provoquer une demande de capture d'image de la part d'une caméra à haute définition. Une fois l'image capturée, celle-ci est transmise à un module analytique qui en sortira les principales caractéristiques recherchées, puis les intégrera à une base de données. Ensuite, un module produisant des contraventions en fonction des besoins pourra, de manière automatique, faire son travail.
