Université de Sherbrooke – SCS

27 août

Au menu :

• Survol du plan de cours, du document d'accompagnement au plan de cours, du projet de session et des grands thèmes qui seront couverts au cours des prochaines semaines
• Coup d'oeil en surface sur les sockets
• Vocabulaire, et questionnements (avec perspective historique multifacettes) sur le sens des mots « client » et « serveur »
• Petit survol d'un programme multiprogrammé banal et non-portable
• Petit survol d'un programme multiprogrammé banal et portable

Dans les notes de cours, ce que nous avons fait touche aux pages suivantes :

• SCS – Volume 00, du début à la fin
• SCS – Volume 01, pp. 29-38

#include <print> // C++23 :)
#include <thread>
#include <chrono>
#include <atomic>
#include <utility>
using namespace std;
using namespace std::chrono;

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

int main() {
   enum { N = 1'000'000 };
   auto [r0, dt0] = test([] {
      int n{ 0 };
      thread th0{ [&n] {
         for (int i = 0; i != N; ++i)
            ++n;
      } };
      thread th1{ [&n] {
         for (int i = 0; i != N; ++i)
            ++n;
      } };
      th1.join();
      th0.join();
      return n;
   });
   auto [r1, dt1] = test([] {
      atomic<int> n{ 0 };
      thread th0{ [&n] {
         for (int i = 0; i != N; ++i)
            ++n;
      } };
      thread th1{ [&n] {
         for (int i = 0; i != N; ++i)
            ++n;
      } };
      th1.join();
      th0.join();
      return n.load();
   });
   print("Sans atomique : {} en {}\n", r0, duration_cast<microseconds>(dt0));
   print("Avec atomique : {} en {}\n", r1, duration_cast<microseconds>(dt1));
}

Sans atomique : 1266874 en 3870us
Avec atomique : 2000000 en 10566us

#include <iostream>
#include <thread>
#include <chrono>
#include <atomic>
#include <utility>
using namespace std;
using namespace std::chrono;

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

int main() {
   enum { N = 1'000'000 };
   auto [r0, dt0] = test([] {
      int n{ 0 };
      thread th0{ [&n] {
         for (int i = 0; i != N; ++i)
            ++n;
      } };
      thread th1{ [&n] {
         for (int i = 0; i != N; ++i)
            ++n;
      } };
      th1.join();
      th0.join();
      return n;
   });
   auto [r1, dt1] = test([] {
      atomic<int> n{ 0 };
      thread th0{ [&n] {
         int m = 0;
         for (int i = 0; i != N; ++i)
            ++m;
         n += m;
      } };
      thread th1{ [&n] {
         int m = 0;
         for (int i = 0; i != N; ++i)
            ++m;
         n += m;
      } };
      th1.join();
      th0.join();
      return n.load();
   });
   cout << "Sans atomique : " << r0 << " en "
        << duration_cast<microseconds>(dt0) << '\n';
   cout << "Avec atomique : " << r1 << " en "
        << duration_cast<microseconds>(dt1) << '\n';
}

Sans atomique : 1083643 en 3071us
Avec atomique : 2000000 en 184us

3 sept.

Au menu, cours à saveur technique, mais on ne parle pas de technique banale ici, ne vous en faites pas. Vous devriez trouver de quoi nourrir votre cerveau dans le cours de cette séance :

• Comprendre les Data Races et leurs conséquences
• Bases de multiprogrammation, façon traditionnelle :
  • introduction aux joies et aux peines de la synchronisation (dont Mutex et Autoverrou)
  • pour les intéressé(e)s aux questions de design architectural « micro », les idiomes classe incopiable, RAII sont couverts lors de cette séance
    • habituellement, je couvre aussi l'idiome pImpl (nous verrons si cela vous convient)
    • je le fais dans un réexamen de la classe Mutex, dans une optique de portabilité
• Introduction à C++ 11 (et plus récent) de même qu'à son modèle de multiprogrammation (premier contact) :
  • introduction aux expressions λ
  • introduction plus formelle à std::thread et à std::mutex, de même qu'aux bases des saines pratiques de programmation avec ces outils
  • liens avec l'évolution des pratiques traditionnelles
  • introduction aux condition_variable
  • introduction à la programmation par promesses

Dans les notes de cours, ce que nous avons fait touche aux pages suivantes :

• SCS – Volume 01, pp. 31-40 (exemple non-portable de programme multiprogrammé)
• SCS – Volume 01, pp. 46-74 (bases sur les outils de synchronisation)
• SCS – Volume 01, appendice 08 (portabilité et approche RAII)
• SCS – Volume 01, pp. 17-28

10 sept.

Au menu :

• Q00
• Bases appliquées sur les sockets, code et tests à l'appui
  • à cet effet, vous trouverez les sources de plusieurs projets utilisant des sockets dans la section Sources et exemples du site de votre chic prof
  • vous trouverez ici le code du client très simple et du serveur très simple
• Survol du marshalling et de ses contraintes (ce qui peut circuler sur un lien réseau)
• Bref regard sur le transfert de structures de grande taille (p. ex. : un fichier texte, un fichier binaire)
• Exemples concrets avec sockets bloquants
• Discussion du fonctionnement des sockets non-bloquants et de leur utilité (ou non)
• Quelques considérations protocolaires
• Discussion du fonctionnement des sockets non-bloquants et de leur utilité (ou non)

Dans les notes de cours, ce que nous avons fait touche aux pages suivantes :

• SCS – Volume 02, pp. 6-39

17 sept.

Au menu :

• À venir

24 sept.

Au menu :

• À venir

1 oct.

Au menu :

• À venir

8 oct.

Au menu :

• À venir

29 oct.

Au menu :

• À venir

5 nov.

Au menu :

• À venir

12 nov.

Au menu :

• À venir

19 nov.

Au menu :

• À venir

26 nov.

Au menu :

• À venir

3 déc.

Au menu :

• Votre présentation du fruit de vos labeurs tout au long de la session
  • Comptera à la fois comme Q08 et comme une démonstration de L02 (il ne vous restera qu'à remettre la documentation)

10 déc.

Vous trouverez ici les sources du projet ClientTresSimple

Vous trouverez ici les sources du projet ServeurTresSimple

Vous trouverez ici les sources du projet ClientTresSimpleOO

Vous trouverez ici les sources du projet ServeurTresSimpleOO

Vous trouverez ici les sources du projet SocketFluxLib

Vous trouverez ici les sources du projet SocketFluxClient

Vous trouverez ici les sources du projet SocketFluxServeur

Exemple simple de SCS par composants avec C++ dans le modèle COM (projet construit pour Visual Studio 2022 avec C++ 17) :

• Client console
• Interface IDL
• Serveur à contexte interne

Refactorisation de l'exemple simple de SCS par composants avec C++ dans le modèle COM (projet construit pour Visual Studio 2017 avec C++ 17) :

• Client console
• Interface IDL
• Assemblage par implémentations partielles
• Pointeurs intelligents
• Serveur à contexte interne

Exemple simple de SCS par composants avec C++ dans le modèle COM (projet construit pour Visual Studio 2015 avec C++ 14) :

• Client console
• Interface IDL
• Bibliothèque de marshalling
• Serveur à contexte externe

Exemple simple de SCS par composants avec client .NET en C# et serveur C++ ISO mêlant les modèles COM et .NET (projet construit pour Visual Studio 2008) :

• Client console
• Interface IDL
• Bibliothèque de types
• Coclasse
• Bibliothèque de marshalling
• Serveur à contexte externe

Exemple simple de SCS par composants avec client C++ ISO et serveur .NET en C# (projets construits pour Visual Studio 2008) :

• client console
• bibliothèque de types générée à partir du code .NET
• importation (directive non portable #import) de la bibliothèque de types
• serveur à contexte interne (mais chargé par le CLR de .NET, donc en pratique le contexte est externe).

Nous avons aussi vu un exemple de client C++ pour serveur .NET en intégrant le chargement du CLR de .NET lors du lancement du programme C++, et en ajoutant au projet C++ des références sur les assemblages .NET souhaités. Cette approche repose sur le template gcroot de <vcclr.h>.

Exemple de mise en application de l'approche Map/ Reduce, avec programmation par promesses (mieux connu sous le nom de futures), délégués et Thread Pooling (en C++ ISO, projet Visual Studio 2008).

Cliquez sur cette cible pour aller au document portant sur les classes imbriquées

Cliquez sur cette cible pour aller au document portant sur les templates

Cliquez sur cette cible pour aller au document portant sur les singletons

Cliquez sur cette cible pour aller au document portant sur les mutex portables

Cliquez sur cette cible pour aller au document portant sur les autoverrous

Cliquez sur cette cible pour aller au document portant sur les objets autonomes

Cliquez sur cette cible pour aller au document portant sur les méthodes volatiles

Vous trouverez ici un petit document expliquant comment déboguer un contexte externe COM (un exécutable dans lequel résident des composants COM).

Vous trouverez ici l'examen final des cohortes 01 et 02 pour IFT756

Vous trouverez ici l'examen final de la cohorte 03 pour IFT756