Université de Sherbrooke – SCS

28 août

Au menu :

• Survol du 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 <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] {
         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();
   });
   cout << "Sans atomique : " << r0 << " en "
        << duration_cast<microseconds>(dt0) << '\n';
   cout << "Avec atomique : " << r1 << " en "
        << duration_cast<microseconds>(dt1) << '\n';
}

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

4 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

11 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

25 sept.

Au menu :

• Q01
• J'avais des plans pour ce soir mais j'ai restructuré un peu. Seront vus plus tard :
  • Suites sur les bases de multiprogrammation avec des applications efficaces de la synchronisation : illustration par une zone de transit
  • Objets qualifiés volatile (sujet controversé!). Il se peut que j'escamote ceci et que j'y revienne plus tard (c'est intéressant, mais périphérique à notre propos)
  • Survol des sockets non-bloquants
• Ont été faits ce soir :
  • Début d'un survol de l'approche par composants
  • Premiers pas avec l'approche par composants
• Pour faciliter la conciliation études-famille dans certains cas, j'ai enregistré la séance de ce soir. Elle sera disponible par Teams si vous êtes intéressé(e)s à la vivre... ou à la revivre. Je ne garantis pas la qualité (c'était une décision un peu impromptue), mais c'était de bon coeur!

Avec cette première approche, nous entreprenons la couverture, avec code natif (en C++) à la fois du côté client et du côté serveur, la mise en place d'un SCS complet réalisant une tâche banale. Nous utilisons pour cette fin un serveur à contexte interne.

Les sources des exemples sont disponibles ici

2 oct.

Au menu :

• Q02
• Refactorisation de la version reposant sur un serveur à contexte interne
• Approche reposant sur un serveur à contexte externe. Les sources des exemples sont disponibles ici

9  oct.

Au menu :

• Q03
• Drôle de soirée en vue. Vous avez une relâche de deux semaines qui s'annonce, et j'ai quelques sujets que j'avais remis à plus tard parce que nous explorions des trucs qui méritaient d'être vus ensemble, alors ce sera un peu pêle-mêle aujourd'hui :
  • Suites sur les bases de multiprogrammation avec des applications efficaces de la synchronisation : illustration par une zone de transit
  • Objets qualifiés volatile (sujet controversé!). Il se peut que j'escamote ceci et que j'y revienne plus tard (c'est intéressant, mais périphérique à notre propos)
  • Survol des sockets non-bloquants
  • Petit détour pour expliquer le faux partage et l'impact des variables globales sur la vitesse des programmes (exprimé autrement : l'impact de la Cache)
  • Mention brève de considérations de taille et d'alignement
  • Coup d'oeil rapide sur les objets autonomes (et retour sur std::thread), si le temps le permet, pour réfléchir sur des enjeux profonds d'architecture logicielle... et rire un peu de votre chic prof!        

30 oct.

Au menu :

• Q04
• Cours à saveur pratique, avec votre chic prof qui fait des démonstrations, et où on intègre des technologies :
  • bibliothèques de types
  • système avec client C++ et serveur C#, de deux façons différentes
  • système avec client C# et serveur C++
  • une brève discussion des COM-Callable Wrappers (CCW) et des Runtime-Callable Wrappers (RCW)
• Quelques particularités des interfaces IDL :
  • paramètres à la fois entrants et sortants
  • le rôle du proxy dans la validation
• Approche par composants selon des modèles d'interactions plus complexes :
  • interaction multi-approches
  • appels asynchrones par poussée

6 nov.

Au menu :

• Q05
• Survol rapide de quelques trucs avec JavaScript. Voir
  •  ../../Sujets/Web/JavaScript-Somme-etc.html
  • ../../Sujets/Web/JavaScript-Collin-Maillard.html
  • ../../Sujets/Web/JavaScript-Objets.html
  • ../../Sujets/Web/JavaScript-Fonctions.html
  • ../../Sujets/Web/JavaScript-Foncteurs.html
  • ../../Sujets/Web/JavaScript-penser-fonctionnel.html
  • petit mot sur jQuery et Node.js
• Penser un SCS pour milieux fermés, en comparaison avec penser un SCS pour le Web
  • enjeux
  • philosophie
• Introduction aux services Web et aux trucs Web de manière générale
  • vocabulaire
  • discussion brève de asm.js et de WebAssembly
  • approche Ajax
  • liens infrastructurels avec les technologies déjà couvertes dans le cours
  • WSDL
  • XML
  • SAX
  • DOM
  • SOAP, qui n'est pas la même chose que SOA
  • etc.
• Survol historique de la mouvance Web 2.0
• Survol de ce qu'est (ou ce que cherche à devenir) le Web sémantique
  • En prime, petit tour d'horizon de la complexité algorithmique
• Modèles architecturaux et interopérabilité (détails à venir), en particulier le style architectural REST
  • Exemple simple : ../../Sources/service-REST-JavaScript-sans-cadriciel.html
  • Définir une API de type REST : à quoi faire attention
  • Gérer les erreurs dans une API de type REST
• On bavarde sécurité, à partir d'un fait vécu
  • J'ai fait des diapos pour vous. En espérant que ce soit utile : Survol_OAuth.pdf

13 nov.

Au menu :

• Présentation d'un chic conférencier, Jean-Philippe Paquette. La rencontre se fera en présence au campus Longueuil. Le synopsis de sa présentation va comme suit :

20 nov.

Au menu :

• Q06
• Q07
• Suite de S08

De plus, selon le temps qu'il nous reste :

• Excursions dans d'autres langages :
  • Quelques exemples avec le langage Go
  • Quelques exemples avec le langage Erlang

Faut de temps, je n'ai pas couvert :

• Survol de ce que sont les Blockchains
  • La position de Satoshi Nakamoto (Peter Todd?) est autant idéologique que technique
  • Sur le plan technique, il y a des raisons pour avoir recours à des algorithmes à base d'orchestration, tout comme il y a des raisons d'avoir recours à des algorithmes à base de chorégraphie
• La mémoire transactionnelle (versions matérielle et logicielle)

Cette rencontre se tiendra à distance, par Teams

27 nov.

Au menu :

• Q09
• Présentation de Jean-François Pezet, qui oeuvre aux caisses Desjardins, en particulier dans la gestion du cycle de vie des services. Cette rencontre se tiendra à distance, par Teams.

4 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)

11 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