La Portabilité Temps-Réel

 

Une fois les spécifications réalisées, il faut ensuite implémenter ces spécifications. Or, pour pouvoir être intéressantes pour les milieux industriels, nos applications doivent pouvoir tourner sur n'importe quel système supportant le temps-réel (UNIX étendu, VXWORKS, etc...). Et pour ce faire, il faut que les primitives faisant appel à la gestion de ce temps-réel (gestion du temps qui n'est pas faite au niveau du noyau réactif, des timers, de la mémoire, etc...) soient compatibles d'un système à un autre. Par exemple, si on a besoin de créer un compteur, la fonction utilisée pour cela, doit pouvoir être comprise de la même manière et ceci indépendamment du système supportant le temps-réel choisi, même si au niveau de l'implémentation même de cette fonction les systèmes adoptent des choix différents, selon les caractéristiques de leur architecture.

Pour atteindre cette portabilité au niveau des systèmes temps-réel, une norme s'est créée : POSIX ou Portable Operating System Interface [16]C'est une norme, standardisée par ANSI et ISO. Elle propose la spécification d'un ensemble de fonctions permettant de solliciter les services de base d'un système d'exploitation. L'objectif est de permettre le développement d'applications portables au niveau du code source.

Cette norme ne constitue pas la définition d'un système d'exploitation. Elle fournit une liste de points d'accès aux services du système : pour chaque fonction, le comportement attendu dans les différentes circonstances susceptibles de se produire est complètement défini. Le but de cette norme est de masquer les spécificités des systèmes sous-jacents.

POSIX fournit des moyens de rendre portables, des applications écrites pour un système d'exploitation donné, et de rendre l'écriture d'un programme plus simple. Ainsi dans les systèmes tels que SOLARIS qui sont conformes à une version de POSIX, des bibliothèques sont fournies pour permettre d'utiliser la couche POSIX. Cela se traduit comme suit :

• au niveau de la compilation :
  Les systèmes POSIX sont censés supporter un langage standard : le plus souvent le C-ANSI. Donc, il faut que le compilateur de l'application en comprennent les facilités pour utiliser la couche POSIX.
  L'application qui souhaite utiliser des fonctionnalités POSIX, devra faire appel, dans son code source, aux fonctions compatibles avec POSIX, qui sont regroupées dans les fichiers comprenant les entêtes des fonctions POSIX.
• au niveau des fichiers d'entêtes :
  Ces fichiers comprennent un ensemble d'entêtes qui définit l'interface POSIX supporté par le système. Dès que l'on a besoin d'une entête particulière dans une application, on inclue dans le code de l'application le fichier qui convient.
• au niveau des librairies :
  Les librairies contiennent les objets qui implémentent les fonctionnalités POSIX. A l'édition de lien, ces librairies sont à lier à l'application ou à l'exécution si les librairies sont partagées dynamiquement.
• au niveau de l'exécution :
  Une fois l'application compilée et traitée par l'éditeur de lien, l'exécutable pourra être chargé sur une machine temps-réel supportant les fonctionnalités POSIX. Ainsi on peut distinguer l'environnement de compilation et de celui de son exécution. Ceci est très intéressant car, dans la plupart des cas, les applications sont d'abord développées sur des plateformes expérimentales, et sont ensuite transférées vers les milieux industriels.

Voici quelques exemples de fichiers d'entêtes POSIX :

• le fichier <unistd.h> : c'est le fichier d'entêtes qui définit la conformité POSIX. Dans ce fichier, on trouve la définition de constantes ou de macros optionnelles que comprend un système POSIX. On y trouve la déclaration des constantes NULL, POSIX_VERSION ou encore _POSIX_TIMERS.
• le fichier <signal.h> : c'est le fichier d'entêtes qui sert à décrire les signaux POSIX. Ce fichier existe déjà dans le système standard UNIX. Dans ce fichier, on trouve la définition
  • des signaux POSIX tel que SIGALRM, SIGKILL ;
  • des structures de données nécessaire à la gestion des différents types de signaux comme strut sigevent ;
  • les fonctions qui gèrent les signaux comme int kill(pid_t, int) ;.