Partager les ressources critiques avec les Sémaphores

Le module semaphore permet de limiter le nombre de tâches qui accèdent simultanément à une ressource. Il permet également de synchroniser tâche et interruption. Cette page détaille le fonctionnement et l'utilisation des fonctions de ce module.

1. Synthèse des fonctions

Les fonctions de ce module sont déclarées dans le fichier mk_semaphore.h :

2. Fonctionnement

Un sémaphore est un compteur à jetons. Le nombre de jetons est défini à la création. Il correspond au nombre de tâches pouvant accéder simultanément à la ressource protégée par le sémaphore. Un jeton est soit disponible, soit non disponible. Quand il est non disponible, le jeton est détenu par une tâche.

La figure ci-dessous montre l'état initial d'un sémaphore constitué de 3 jetons dont seulement un est utilisé :

Les sémaphores sont alloués par le noyau dans l'espace privilégié. Ils sont constitués d'une variable stockant le nombre total de jetons (TokenNumber), d'une variable stockant le nombre de jetons non disponibles (UsedToken) et d'une liste stockant les tâches en attente d'un jeton (BlockedList).

Les tâches interagissent avec un sémaphore de plusieurs manières. Lors d'un take, la tâche demande au noyau de lui attribuer un jeton. Si un jeton est disponible, le noyau le fournit et la tâche poursuit alors son exécution :

Lorsqu'aucun jeton n'est disponible, la tâche peut décider de se bloquer en attendant la libération d'un jeton.

La figure ci-dessous montre la situation où trois tâches sont en attente d'un sémaphore qui n'a plus de jeton :

Les tâches 2 et 7 sont les tâches les plus prioritaires mais possèdent une priorité identique. Dans cette situation, la tâche réveillée en premier sera la première à avoir été insérée dans la liste. Dans l'exemple ci-dessus, le noyau réveillera d'abord la tâche 7 puis les tâches 2 et 3.

Lors d'un release, un jeton pris par une tâche est restitué au sémaphore. Si au moins une tâche est en attente de celui-ci, le noyau attribue immédiatement le jeton à la tâche la plus prioritaire :

La tâche 7 s'est vue attribuer le jeton et a donc été retirée de la liste d'attente. La figure ci-dessous montre l'évolution du sémaphore après 3 release successifs :

On remarque que toutes les tâches en attente d'un jeton ont été servies et qu'un jeton supplémentaire s'est libéré.

3. Avantages et inconvénients

Un sémaphore possède les avantages suivants :

• ✔Il permet à plusieurs tâches d'utiliser simultanément une ressource.
• ✔Il permet de synchroniser tâche et vecteur d'interruption.
• ✔Il n'a pas besoin de buffer applicatif.

Néanmoins, un sémaphore n'a pas de propriétaire. Le noyau ne sait pas quelle tâche détient les jetons et ne peut donc pas réaliser d'héritage de priorité. Une tâche peu prioritaire détenant un jeton peut alors retarder une tâche très prioritaire (inversion de priorité).

4. Utilisation

La création d'un sémaphore s'effectue avec la fonction mk_semaphore_create. L'exemple ci-dessous crée un sémaphore binaire ne possédant qu'un seul jeton non utilisé :

/* Pointeur du sémaphore */
K_MK_PRIVILEGED_BSS_MEMORY T_mkSemaphore* g_semaphore;

/* Une tâche privilégiée */
void mk_task_privileged ( T_mkAddr p_param )
{
   /* Déclaration de la variable de retour */
   T_mkCode l_result;

   /* Création d'un sémaphore binaire (1 jeton au total) */
   /* Aucun jeton n'est utilisé à la création */
   /* Il est protégé et ne peut pas être manipulé par des tâches non privilégiées */
   l_result = mk_semaphore_create ( &g_semaphore, K_MK_AREA_PROTECTED,
      1, /* Nombre total de jetons */
      0 ); /* Nombre de jetons utilisés */

   /* ... */
   for ( ;; ) ;
}

Après sa création, un jeton est pris avec mk_semaphore_take et restitué avec mk_semaphore_release. Le paramètre p_mkTick définit le comportement de la tâche lorsque le sémaphore n'a plus de jeton disponible. L'exemple ci-dessous montre comment protéger l'accès à une ressource unique avec un sémaphore binaire :

/* Une tâche privilégiée */
void mk_task_privileged ( T_mkAddr p_param )
{
   /* Déclaration de la variable de retour */
   T_mkCode l_result;

   while ( 1 )
   {
      /* La tâche attend au maximum 10 ticks qu'un jeton se libère */
      l_result = mk_semaphore_take ( g_semaphore, 10 );

      if ( l_result == K_MK_OK ) {
         /* Le jeton a été pris, la ressource peut être utilisée ... */

         /* Libération du jeton */
         l_result = mk_semaphore_release ( g_semaphore );
      }
      else if ( l_result == K_MK_ERROR_TIMEOUT ) {
         /* Aucun jeton ne s'est libéré pendant 10 ticks */
      }
      else {
         /* Gestion des erreurs ...  */
         /* K_MK_ERROR_PARAM, K_MK_ERROR_ISR, K_MK_ERROR_RIGHT */
      }
   }
}

Un sémaphore à compteur permet de limiter l'accès à des ressources identiques. L'exemple ci-dessous autorise trois tâches à utiliser simultanément un des trois canaux de communication d'un périphérique :

/* Création d'un sémaphore à compteur possédant 3 jetons disponibles */
l_result = mk_semaphore_create ( &g_semaphore, K_MK_AREA_PROTECTED, 3, 0 );

/* ... */

/* Dans chacune des tâches utilisatrices */
/* Les trois premières tâches obtiennent un jeton et les autres seront */
/* bloquées tant qu'aucun jeton ne s'est libéré */
l_result = mk_semaphore_take ( g_semaphore, K_MK_TASK_WAIT_FOREVER );

if ( l_result == K_MK_OK ) {
   /* Utilisation d'un canal ... */

   /* Le jeton est libéré. Si des tâches sont en attente, la tâche */
   /* la plus prioritaire sera réveillée */
   l_result = mk_semaphore_release ( g_semaphore );
}

Un sémaphore peut également synchroniser une tâche et une interruption en utilisant la fonction mk_semaphore_release. Pour ce faire, un sémaphore binaire doit être créé avec son jeton utilisé :

/* Tâche de traitement */
void mk_handler_task ( T_mkAddr p_param )
{
   /* Création d'un sémaphore binaire dont le jeton est non disponible */
   T_mkCode l_result = mk_semaphore_create ( &g_semaphore, 
      K_MK_AREA_PROTECTED,
      1,   /* Nombre total de jetons */
      1 ); /* Nombre de jetons utilisés */

   while ( 1 )
   {
      /* Attente infinie de l'interruption */
      l_result = mk_semaphore_take ( g_semaphore, K_MK_TASK_WAIT_FOREVER );

      if ( l_result == K_MK_OK ) {
         /* Traitement de l'événement ... */
      }
   }
}

/* Vecteur d'interruption */
void IRQHandler ( void )
{
   /* Réveil de la tâche de traitement */
   T_mkCode l_result = mk_semaphore_release ( g_semaphore );

   /* Si K_MK_ERROR_TIMEOUT, tous les jetons sont déjà disponibles */
   ( void ) l_result;
}

La dernière fonction de l'API est la fonction mk_semaphore_delete. Elle permet de détruire le sémaphore en demandant au noyau de le désallouer :

/* Suppression du sémaphore */
T_mkCode l_result = mk_semaphore_delete ( g_semaphore );

/* Si une erreur s'est produite */
if ( l_result != K_MK_OK )
{
   /* Gestion des erreurs ...  */
   /* K_MK_ERROR_PARAM, K_MK_ERROR_ISR, K_MK_ERROR_RIGHT */
}

5. Protéger ses sémaphores

Les sémaphores peuvent être créés avec les attributs K_MK_AREA_PROTECTED ou K_MK_AREA_UNPROTECTED.

Lorsque l'attribut K_MK_AREA_PROTECTED est utilisé, il est impossible pour une tâche non privilégiée de créer ou de manipuler un sémaphore. Un sémaphore non protégé doit donc être utilisé pour synchroniser des tâches privilégiées avec des tâches non privilégiées.

Du fait de leur niveau d'exécution, l'ensemble des règles de protection ne s'applique pas aux vecteurs d'interruption. La fonction mk_semaphore_release peut donc libérer les jetons d'un sémaphore protégé lorsqu'elle est exécutée dans un vecteur d'interruption.

Les sémaphores étant alloués par le noyau dans l'espace privilégié, aucune règle de placement ne s'applique. Seules les variables stockant leurs adresses doivent être accessibles aux tâches qui les utilisent. Les règles de placement de ces variables sont détaillées dans l'article Protéger son programme avec Mk.

6. API

T_mkCode mk_semaphore_create ( T_mkSemaphore** p_mkSemaphore, 
   uint32_t p_mkAreaType, uint32_t p_mkTokenNumber, 
   uint32_t p_mkInitialTokenNumber );
                  

T_mkCode mk_semaphore_take ( T_mkSemaphore* p_mkSemaphore, 
   uint32_t p_mkTick );
                  

T_mkCode mk_semaphore_release ( T_mkSemaphore* p_mkSemaphore );
                  

T_mkCode mk_semaphore_delete ( T_mkSemaphore* p_mkSemaphore );