Optimiser un système ordiné

industriel
247-637-LI
Types de tâches, sémaphores et
systèmes d'exploitation embarqués
 Aujourd'hui
• La signification de « parallèle » en
programmation
• Les échelles de temps et les types de tâches
• La synchronisation des opérations
• Retour sur le service de base de temps
• Laboratoire…
 Le « parallèle » en programmation
• Le cœur d’un microcontrôleur peut-il faire plus d’une opération à la fois?
– Non en principe, oui ou presque en pratique à cause du « pipelining »
• Peut-on parler d’opérations en parallèle quand il n’y a qu’un cœur?
– Non si on s’en tient à l’échelle des opérations, mais oui si on est à l’échelle
« humaine »
• Peut-on parler d’opérations en parallèle quand il y a plus d’un cœur dans
un microcontrôleur?
– Oui en autant que les cœurs n’aient pas à interagir entre eux
• Qu’arrive-t-il quand des cœurs interagissent entre eux?
– Les opérations ne se font plus strictement en parallèle et les cœurs doivent
synchroniser leurs opérations en viennent à opérer de façon séquentielle par
moments
• Est-ce que la notion d’opérations en parallèle est liées à la notion de temps
d’exécution des tâches?
– Oui…
Le « parallèle » en programmation (suite)
• Quelles sont les types de tâches qui sont à considérer dans
un contexte d’opérations en parallèle?
– Les tâches « ordinaires », les tâches « pas pressantes » et les
tâches « urgentes »
• Les tâches urgentes peuvent-elles se faire en parallèle?
– Non par définition
• Les tâches lentes peuvent-elles se faire en parallèle?
– Non à moins de les subdiviser, mais il n’est plus question de
tâches en parallèle dans ce cas si on se place à l’échelle des
tâches lentes
• Les tâches ordinaires peuvent-elle se faire en parallèle?
– Oui parce qu’on l’observe à l’échelle humaine
 Les échelles de temps et le code
• De quoi est constitué le code d’un programme pour microcontrôleur?
– D’une section d’initialisation
– D’une boucle
– D’interruptions
• Quels types d’interruptions doit-on prendre en compte lorsqu’on
programme un microcontrôleur?
– Les interruptions qui surviennent de façon aléatoire
– Les interruptions qui se produisent périodiquement
• Comment peut-on associer les tâches à réaliser aux éléments du
code d’un microcontrôleur?
– Tâches lentes réalisées dans la boucle
– Tâches urgentes réalisées lors d’interruptions aléatoires
– Tâches ordinaires réalisés lors d’interruptions périodiques
Retour sur le module serviceBaseDeTemps
• De quoi faut-il disposer pour pouvoir réaliser des tâches en
parallèle?
– D’interruptions périodiques
• Comment peut-on générer des interruptions « périodiques »?
– Interruptions « logicielles » si la précision des mesures de temps n’est pas essentiel
– Interruptions « matérielles » en configurant un « timer » adéquatement
– Interruptions « externes » en réagissant à des signaux produits par un système qui
est relié au microcontrôleur
• Comment peut-on gérer les tâches réalisées périodiquement?
– De façon « collaborative », « préemptive » ou autrement
• Des exemples de?
– « collaboration »: ce qu’on fait en 247-637 avec serviceBaseDeTemps
– « préemption »: des systèmes d’exploitation comme FreeRTOS, Linux, etc. qui se
permettent d’interrompre la réalisation d’une tâche pour en faire une autre
 La synchronisation des opérations
• À partir de quand n’est-il plus possible de faire des opérations en parallèle?
– Lorsqu'il y a interaction entre les tâches qui se font en parallèle
• Comment peut-on gérer la durée des interactions pour passer plus de temps à opérer en
parallèle?
– En sachant quand débute l’interaction et quand elle se termine
– En préparant les données à échanger avant de lancer l’interaction
– En traitant les données échangées après avoir mis fin aux interactions
• Qu’est-ce qu’un « sémaphore »?
– Un moyen de lancer et de mettre fin aux interactions
• Qu’est-ce qu’un « tampon »?
– Un moyen de passer de l’information lors des interactions
• Quels sont les types d’interactions à considérer?
– Les « productions » de données
– Les « demandes » de données
• Quel est le rôle des sémaphores dans le cas d'une production de données?
– Indiquer que de l'information est disponible ou qu'elle a été traitée
• Quel est le rôle des sémaphores dans le cas de demandes de données?
– Indiquer qu'une requête pour obtenir de des données est active ou qu'elle a été traitée
 La synchronisation des opérations (suite)
• Comment peut-on gérer les interactions qui impliquent des « productions » de données?
– La tâche qui « produit » les données les places dans le tampon
– La tâche qui produit les données lance l’interaction en utilisant le sémaphore pour indiquer que les
données sont disponibles
– La tâche qui utilise les données les récupère
– La tâche qui utilise les données met fin à l’interaction à l’aide du sémaphore pour indiquer que les
données ont été récupérées
• Qu’arrive-t-il si la tâche qui utilise les données n’utilise pas le sémaphore?
– Elle ne dispose pas de moyens pour savoir quand une interaction est lancée
• Que doit-on faire si plus d’une tâche utilisent les données produites par une autre tâches?
– Prévoir un mécanisme à plusieurs tampons et/ou à plusieurs sémaphores…
• Est-il toujours nécessaire de mettre fin aux interactions à l’aide du sémaphores?
– Non si la gestion des interactions le permet (ex. données perdues acceptables)
• Un exemple de tâche qui « produit » des données:
– Un interface qui se sert à répétition des fonctionnalités d’un pilote pour ADC pour produire des
valeurs de potentiomètre qui sont utilisées par un processus de commande de vitesse de moteur.
 La production d'informations
Le "producteur" Le "producteur" Le "producteur"
se sert du ne fait rien en ne fait rien en
Le "producteur"
sémaphore pour attendant de attendant de
écrit les données
dire que de produire de produire de
dans un tampon
l'information est nouvelles nouvelles
disponible données données

Le "client" se
Le "client" ne fait Le "client" se sert
prépare à lire les
rien, car le Le "client" du sémaphore
données du
sémaphore ne récupère les pour indiquer
tampon en
dit pas qu'il y a données en qu'il a traité
apprenant que
de l'information lisant le tampon l'information
de l'information
de disponible disponible
est disponible
 Production sans blocage du producteur
• Initialisation du • Tâche périodique du
producteur: client:
interfaceX_semaphore = INFORMATION_TRAITEE; if(interfaceX_semaphore==INFORMATION_TRAITE
E)
• Tâche périodique du {return;}
processusY_lecture = interfaceX_tampon;
producteur: interfaceX_semaphore = INFORMATION_TRAITEE;
interfaceX_tampon = litUneValeur();
interfaceX_semaphore = INFORMATION_DISPONIBLE; • Le client attend après le
• Le producteur écrit sans producteur avant de lire
se soucier du client • Le client se sert du
• Des données sont sémaphore pour éviter
perdues si le client n'est de lire le tampon à
pas assez rapide répétition
 Production avec blocage du producteur
• Initialisation du producteur: • Tâche périodique du client:
interfaceX_semaphore = INFORMATION_TRAITEE; if(interfaceX_semaphore==INFORMATION_TRAITEE)

• Tâche périodique du
{return;}
processusY_lecture = interfaceX_tampon;

producteur:
interfaceX_semaphore = INFORMATION_TRAITEE;

if(interfaceX_semaphore == INFORMATION_TRAITEE)
{return;}
if(interfaceX_semaphore == INFORMATION_DISPONIBLE;
• Le client attend après le
interfaceX_tampon = litUneValeur();
interfaceX_semaphore = INFORMATION_DISPONIBLE;
producteur avant de lire
• Le client se sert du sémaphore
pour éviter de lire le tampon à
• Le producteur se sert du
répétition
sémaphore pour lire sur
• Les pertes de données ne sont
demande
possibles parce que tant le
• Il n'y pas de pertes de données
client que le producteur
même si le client n'est pas
utilisent le sémaphore
rapide
 La synchronisation des opérations (suite)
• Comment peut-on gérer les interactions qui impliquent des « demandes » de données?
– La tâche qui peut répondre aux demandes attend les demandes
– La tâche qui demande les données lance l’interaction en utilisant le sémaphore pour indiquer que
les données sont requises
– La tâche qui répond place les données demandées dans le tampon quand elle voit la demande
– La tâche qui répond utilise le sémaphore met fin à l’interaction pour indiquer que la demande a été
traitée
– La tâche qui demande les données les récupère
• Qu’arrive-t-il si la tâche qui demande les données n’utilise pas le sémaphore?
– Elle ne lance pas d’interaction et ne pourra recevoir de réponse
• Qu’arrive-t-il si la tâche qui répond aux demandes n’utilise pas le sémaphore?
– Elle ne permet pas à la tâche qui a fait une demande de savoir que la réponse a été produite.
• Que doit-on faire si plus d’une tâche font une demande à une même tâche?
– Prévoir un mécanisme à plusieurs tampons et/ou à plusieurs sémaphores…
• Un exemple de tâche qui fait une demande de données:
– Un processus de commande de vitesse de moteur qui fait une demande de valeur de potentiomètre
à un interface qui se sert des fonctionnalités d’un pilote pour ADC qui permet de faire des
conversions sur demande.
 Les demandes d'informations
Le "serveur" Le "serveur"
Le "serveur" ne
attend que le utilise le
Le "serveur" écrit fait rien en
sémaphore sémaphore pour
les données dans attendant qu'une
indique qu'une indiquer que la
un tampon autre requête lui
requête est en requête a été
soit adressée
cours traitée

Le "demandeur"
Le "demandeur"
se prépare à
Le "demandeur" ne fait rien en
récupérer Le "demandeur"
utilise le attendant que le
l'information, car récupère
sémaphore pour sémaphore
le sémaphore l'information
formuler une indique que sa
indique que la demandée
requête requête a été
requête a été
traitée
traitée
 Obtention d'informations sur demande
• Initialisation du serveur:
interfaceX_semaphore = REQUETE_TRAITEE;
• Tâche périodique du
serveur:
if(interfaceX_semaphore == REQUETE_TRAITEE)
{return;}
interfaceX_tampon = produitUneDonnee();
interfaceX_semaphore = REQUETE_TRAITEE;
• Le serveur attend une
demande pour produire
une donnée
• Le sémaphore sert à lancer
la tâche de produire une
donnée
• Tâche périodique du client au
moment de faire une demande:
if(interfaceX_semaphore==REQUETE_ACTIVE)
{return;}
interfaceX_semaphore = REQUETE_ACTIVE;
• Tâche périodique du client après
avoir fait une demande:
if(interfaceX_semaphore==REQUETE_ACTIVE)
{return;}
utilseLaDonne(interfaceX_tampon);
• Le client attend de pouvoir faire
une demande
• Le client se sert du sémaphore
pour savoir quand se servir des
données produites par le serveur
 Les réalisations de tâches sur demande
Le "serveur" Le "serveur"
Le "serveur" lit Le "serveur" ne
attend que le utilise le
les données dont fait rien en
sémaphore sémaphore pour
il a de besoin attendant qu'une
indique qu'une indiquer que la
pour faire la autre requête lui
requête est en requête a été
tâche demandée soit adressée
cours traitée

Le "demandeur" Le "demandeur" Le "demandeur" Le "demandeur"

attend que le fournit utilise le poursuit ses
sémaphore l'information sémaphore pour opérations en
indique qu'il requise par le indiquer qu'il attendant de
peut formuler "serveur" pour formule une faire une autre
une requête faire la tâche requête requête
 Réalisation de tâches sur demande
• Initialisation du serveur:
interfaceX_semaphore = REQUETE_TRAITEE;
• Tâche périodique du serveur:
if(interfaceX_semaphore == REQUETE_TRAITEE)
{return;}
réaliseLaTacheDemandee(interfaceX_tampon);
interfaceX_semaphore = REQUETE_TRAITEE;
• Le serveur attend une demande
avant de réaliser une tâche
• Le sémaphore sert à lancer la
tâche
• Le serveur utilise les données
pour accomplir sa tâche
• Le sémaphore sert à indiquer
que la tâche est réalisée
• Tâche périodique du client au
moment de faire une demande:
if(interfaceX_semaphore==REQUETE_ACTIVE)
{return;}
interfaceX_tampon =
informationRequisePourFaireLaTache;
interfaceX_semaphore = REQUETE_ACTIVE;
• Le client attend de pouvoir faire
une demande
• Le client fournit les informations
requises pour faire la tâche
• Le client se sert du sémaphore
pour commander une tâche sur
demande
 Exercices
• Décrire l'équivalent de:
–void faitFaireUneTache(char tampon);
–char litUneDonnee(void);
–char litLaProchaineDonnee(void);
–char faitTraiterUneDonnee(char tampon);
–void faitTraiterDesDonnees(char
*tampon);
– void obtientPlusieursDonnes(char
*tampon);
• Imaginer d'autres scénarios