Cours:InfoEmbarqueeThread : Différence entre versions

De troyesGEII
Aller à : navigation, rechercher
(→‎Semaphores)
(→‎Prolongement possible)
 
(6 révisions intermédiaires par le même utilisateur non affichées)
Ligne 146 : Ligne 146 :
 
*problème des [https://fr.wikipedia.org/wiki/Probl%C3%A8me_des_producteurs_et_des_consommateurs producteurs/consommateurs]
 
*problème des [https://fr.wikipedia.org/wiki/Probl%C3%A8me_des_producteurs_et_des_consommateurs producteurs/consommateurs]
  
 +
[[Image:producteurs_consommateurs.png]]
  
  
 +
Un sémaphore :
 +
*possède une valeur initiale (qui peut être nulle)
 +
*cette valeur correspond au nombre de ressources et est actualisé lors des opérations suivantes.
 +
*propose les fonctionnalités :
 +
**obtenir un nombre de ressources ( bloquant tant que le nombre de ressources nécessaires n'est pas disponible)
 +
**libérer un nombre de ressources
  
  
 
  https://doc.qt.io/qt-5/qsemaphore.html
 
  https://doc.qt.io/qt-5/qsemaphore.html
 +
 +
 +
{{Question|Exercice d'application}}
 +
*On considère 3 tâches distinctes :
 +
**faire clignoter une led pendant 10s à une fréquence de 3Hz
 +
**faire clignoter une led pendant 3s à une fréquence de 1Hz
 +
**faire clignoter une led pendant 1s à une fréquence de 10Hz
 +
*Un bouton permettra de lancer les 3 tâches pour 1 cycle
 +
*Il faut attendre la fin des 3 tâches pour relancer un nouveau cycle
 +
 +
 +
=Prolongement possible=
 +
*[[Cours:QtMqtt|td mqtt]]
 +
*lancer un processus ( ex powerOffScreen powerOnScreen)
  
 
=Ressources=
 
=Ressources=

Version actuelle datée du 9 octobre 2023 à 08:46

Kesako

Pile/Tas

zone mémoire Taille Usage Performances
Stack (pile) fixe variables/paramètres ... des fonctions selon mémoire
Heap (tas) sans objet allocation dynamique un peu moins rapide (gestion du tas, partage entre thread => doit être thread-safe)


utilisation de la pile utilisation du tas 
int f1(int n)
{
   int res;
   res= ...n1;
   return res;
}

int main()
{
  int a,b;
  b=f1(a);
}

int* memoireAllouee = nullptr; // On crée un pointeur sur int
memoireAllouee = malloc(sizeof(int)); // La fonction malloc inscrit dans notre pointeur l'adresse qui a été reservée.

Complexe * z1 = new Complexe(2,5);

Processus

Le lancement d'un programme sous Unix (norme posix ) entraîne la création d'un nouveau processus et donc l'allocation d'une zone mémoire avec plusieurs parties :

ProcessusUnix.gif


  • le segment texte qui contient le programme exécutable
  • le segment statique qui contient les objets globaux et statiques
  • le segment de pile ( stack ) qui contient les données des fonctions
  • le segment de tas ( heap ) qui contient les données allouées dynamiquement ( new / malloc )

Thread

un thread (fil d'instruction, processus léger,...) représente l'exécution d'en ensemble d'instructions.

un processus peut exécuter plusieurs threads. Les threads d'un même processus partagent une grande partie de leur mémoire (mis à part la pile)

L'ordonnanceur du système d'exploitation exécutera les différents threads qui pourront sembler s'exécuter en parallèle même sur un processeur à un seul coeur (core).


ThreadPosix.png 


Attention à la durée de vie des objets dans la pile !!! => préférez le tas ?!


spécialisation de la classe QThread

worker.h worker.cpp 
class Worker : public QThread
{
    Q_OBJECT
public:
    explicit Worker(QObject *parent = nullptr);
    void run() override;
};

Worker::Worker(QObject *parent)
    : QThread{parent}
{
}

void Worker::run()
{
    // les objets qui "vivent" dans le thread doivent être créés dans la méthode '''run'''
    // exec(); // =>lance la boucle d'événement QT
}


Question.jpg Reprendre l'exercice d'observation par scrutation d'une entrée générée par un gbf

Mutex

Dans chaque thread on distingue :

  • section non critique : peut être exécuté sans coordination avec les autres threads
  • section critique  : doit être exécuté par un thread unique => exclusion mutuelle
Un mutex (mutual exclusion) est une structure de données qui permet de contrôler l'accès à une ressource

Un mutex :

  • est associé à une ressource
  • peut être
    • unlocked : la ressource est libre
    • locked  : la ressource est utilisée


Avant chaque accès à une section critique, il convient de :

  • demander le verrouillage du mutex
  • exécuter la section critique
  • libérer le mutex


https://doc.qt.io/qt-5/qmutex.html


Question.jpg Exercice d'application :

  • on dispose 2 boutons sur l'interface graphique
  • une led est connectée sur un gpio
  • 2 tâches (thread) sont en attente
    • l'une fera clignoter la led à 1Hz pendant 5s
    • l'autre fera clignoter la led à 10Hz pendant 1s
  • chaque bouton lancera l'une des tâches
  • il ne devra y avoir qu'une tâche active à la fois

Semaphores

Les sémaphores permettent de résoudre le problème de la synchronisation entre thread, dont :

Producteurs consommateurs.png


Un sémaphore :

  • possède une valeur initiale (qui peut être nulle)
  • cette valeur correspond au nombre de ressources et est actualisé lors des opérations suivantes.
  • propose les fonctionnalités :
    • obtenir un nombre de ressources ( bloquant tant que le nombre de ressources nécessaires n'est pas disponible)
    • libérer un nombre de ressources


https://doc.qt.io/qt-5/qsemaphore.html


Question.jpg Exercice d'application

  • On considère 3 tâches distinctes :
    • faire clignoter une led pendant 10s à une fréquence de 3Hz
    • faire clignoter une led pendant 3s à une fréquence de 1Hz
    • faire clignoter une led pendant 1s à une fréquence de 10Hz
  • Un bouton permettra de lancer les 3 tâches pour 1 cycle
  • Il faut attendre la fin des 3 tâches pour relancer un nouveau cycle


Prolongement possible

  • td mqtt
  • lancer un processus ( ex powerOffScreen powerOnScreen)

Ressources

Récupérée de « http://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:InfoEmbarqueeThread&oldid=18215 »