Remarques préliminaires :

• Prendre connaissance du document : Délais, alarmes et timers sous Unix
• Créer le répertoire tpsys/dirtimer, qui sera considéré comme répertoire courant, jusqu'à une nouvelle indication.
• Comme précédemment, ne testez pas avant que cela vous soit explicitement demandé dans l'énoncé,
• Pensez à consulter les objectifs pédagogiques

Sommaire

Classe CTimevalBase

Classe CTimespecBase

Fonctions sleep() et nanosleep() - Classes CTimeval et CTimespec

exo_02

Première amélioration

Seconde amélioration

Sablier cyclique

Classe CItimervalBase
Classes CTimer...
exo_04

Temps réel, temps virtuel	exo_05
Mode user, mode kernel	exo_06

Introduction

    La première, de conception ancienne, est essentiellement utilisée par les timers Unix. Elle permet de manipuler des délais jusqu'à la micro-seconde (pourvu que la machine et la configuration le permettent). La dernière, d'introduction récente, permet de définir des délais de façon beaucoup plus fine et est conforme à la norme POSIX. Elle est en particulier utilisée par la fonction système nanosleep().

    Malheureusement, aucune des deux n'offre de réelle sécurité dans son utilisation. La documentation indique que la valeur de la donnée membre tv_usec d'un timeval ne doit pas excéder 999 999, que celle de la donnée membre d'un timespec ne doit pas excéder 999 999 999. Mais rien ne permet de garantir le respect de cette contrainte, puisque les données membres sont publiques (c'est une struct), ce qui peut provoquer des erreurs. Considérons par exemple la séquence suivante :
 

timeval tv1 = {3, 1500000};   // le mot "struct" devant timeval serait nécessaire                               // s'il existait une fonction timeval() timeval tv2 = {2, 2500000}; bool egal = timercmp (tv1, tv2, <);  // timercmp[2] est une macro permettant de comparer 2 timeval

    Le booléen egal sera faux après exécution de ces instructions.

    De plus, les opérations arithmétiques sur ces structures ne sont pas complètes.

Sommaire

Découverte des délais

Masquage de l'information par dérivation

    Chargez-les dans vos propres répertoires include et util. Afin de pouvoir les utiliser correctement ultérieurement, passez un peu de temps à étudier leurs spécifications. L'analyse du code peut aussi vous apprendre des choses : voir Rq1 !

Classe CTimevalBase

• publique de la classe abstraite CEditable,
• protégée de la structure timeval (afin de masquer les données membres aux futurs utilisateurs).

• un constructeur par défaut avec deux paramètres : le nombre de secondes et le nombre de micro-secondes,
• un constructeur avec un paramètre de type timeval,
• un destructeur virtuel,
• la fonction virtuelle protégée _Edit() (la classe est dérivée de CEditable) permettant d'afficher les objets sous la forme

[xxx:xxx]

• les accesseurs GetSec() et GetMuSec() permettant de récupérer les valeurs des deux données membres du timeval,
• le modifieur Set() qui permet d'initialiser une durée (avec valeurs par défaut nulles),
• l'opérateur de relation < et l'opérateur d'égalité ==,
• les opérateurs + et -, permettant d'ajouter ou de soustraire deux CTimevalBase,
• la fonction privée Normaliser() qui ramène la donnée "micro-secondes" à l'intérieur des limites 0..999999, et qui est utilisée après chaque opération qui la nécessite,
• un prédicat (fonction booléenne) IsSet() permettant de savoir si au moins un des champs est non nul,
• la fonction Shift() qui ajoute un nombre (positif ou négatif) de secondes et éventuellement de micro-secondes.

    Le constructeur par recopie, et l'opérateur d'affectation, gracieusement offerts par le compilateur, sont utilisables car les données membres ne contiennent pas de pointeurs.

Classe CTimespecBase

Utilisation de la classe CTimevalBase : fonction système select()

    La fonction select() est appelée fonction de multiplexage d'entrées/sorties. Rappelons que les "fichiers" (au sens large d'Unix) peuvent être classés en deux catégories selon que la fonction système read() renvoie 0 lorsqu'ils sont vides (c'est le cas des fichiers disques "normaux") ou qu'elle bloque (normalement) le processus qui l'appelle lorsque le "fichier" est vide (c'est le cas du "fichier" clavier, des sockets, des pipes). Rappelons aussi que la fonction select() est bloquante jusqu'à ce qu'au moins un événement attendu arrive, ou que le délai fixé en dernier paramètre arrive à expiration.
 

exo_01

• Notion de "timeout"
• Utilisation de la fonction select() et des délais
• Liste des fichiers créés ou modifiés : exo_01.cxx, nsSysteme.h, nsSysteme.hxx, Makefile, MakeUtil, INCLUDE_H

    Mettre à jour les fichiers MakeUtil et INCLUDE_H.

    Ecrire un programme qui répète 5 fois une boucle dans laquelle il attend soit une frappe au clavier, soit l'écoulement d'un délai de 5 secondes. Si l'événement est une frappe au clavier, afficher sous la forme suivante (par exemple) :
 

f : caractere lu au bout d'un délai de [1:380000]

le caractère frappé (qui sera lu soit par l'extracteur ">>", soit par la fonction membre get() de la classe istream : faire les deux essais). Si la sortie de la fonction Select() est due à l'épuisement du délai, afficher le message "timeout atteint".

Rq2

    Mettre à jour le fichier Makefile. Compiler et tester les deux possibilités.

Corrigés : exo_01.cxx    -    Makefile    -    nsSysteme.h    -    nsSysteme.hxx    -    MakeUtil    -    INCLUDE_H

Sommaire

Fonctions sleep() et nanosleep() - Classes CTimeval et CTimespec

exo_02

• Interruption et réarmement d'un délai de suspension d'un programme
• Fonction C sleep() et fonction système nanosleep()
• Liste des fichiers créés ou modifiés : exo_02.cxx, Makefile, nsSysteme.h, nsSysteme.hxx, Time.h, Time.cxx, INCLUDE_H, MakeUtil

    Dans la fonction ppal() du fichier exo_02.cxx, faire une boucle jusqu'à ce que le délai, passé en argument de la commande, soit épuisé. Pour cela, appeler la fonction sleep(), en récupérant le délai restant.

    Pour permettre d'interrompre la fonction sleep() sans terminer le programme, dérouter le signal SIGINT avant d'entrer dans la boucle.

    Afficher un message à chaque retour de la fonction sleep(), par exemple :
 

SIGINT reçu; il reste     5 secondes

    Compiler et tester.

    La fonction système nanosleep() a un comportement très analogue à la fonction C. Cependant, elle permet une granularité du temps plus fine, et utilise pour cela la structure struct timespec.

    Ecrire le wrapper Nanosleep() de la fonction nanosleep(), en remplaçant le type timespec par CTimespecBase. Contrairement à la fonction système nanosleep(), il est souhaitable que son wrapper remette à zéro le temps restant lorsque nanosleep() se termine normalement.

    Ajouter à ppal() une nouvelle boucle utilisant Nanosleep(), jusqu'à ce que le délai, passé en argument de la commande ^[3], soit épuisé. Comme précédemment, afficher le délai restant à chaque retour de la fonction Nanosleep().

    Compiler et tester.

Première amélioration

    Une première solution, triviale, consiste à laisser le soin à l'utilisateur de la construire lui-même :
 

const CTimespecBase CstZero (0); // ou simplement  : const CTimespecBase CstZero;  ... if (CstZero == Delai)     ...

    En réalité, les constantes d'une classe doivent être proposées par la classe elle-même. Il suffit de les déclarer et les définir comme membres statiques de la classe.

    En conception objet, une dérivation correspond à une spécialisation : on dérive la classe mammifère en une classe chat par exemple. Dans la pratique de la programmation objets, la dérivation est parfois simplement utilisée pour ajouter quelques commodités à une classe de base. Peu recommandable dans le cas général, car en particulier génératrice de hiérarchies de classes trop volumineuses, cette possibilité est cependant nécessaire, comme nous allons le montrer ici.

    La classe CTimespecBase vous étant fournie, vous ne devez pas en modifier le code. Il ne vous reste plus qu'à la dériver en CTimespec, dans le fichier Time.h placé dans le répertoire include, afin de lui ajouter la déclaration de cette constante. On en profitera pour la doter de quelques possibilités supplémentaires. Dans le fichier Time.cxx correspondant, du répertoire util, ajouter la définition de CstZero (une définition de constante ne doit jamais se trouver dans un fichier inclus, pour éviter d'éventuelles définitions multiples).

    Son utilisation peut être la suivante :
 

CTimespec Delai (5); ... if (CTimespec::CstZero == Delai)     ...

    Lorsqu'une classe est dérivée, la nouvelle classe ne possède que les constructeurs par défaut et par recopie. Si sa classe mère ne les possède pas, il peut être nécessaire de les supprimer. Si sa classe mère possède d'autres constructeurs, il peut être nécessaire de donner les mêmes à la classe fille. C'est le cas ici : la classe CTimespec devra proposer deux constructeurs et un destructeur virtuel.

    Effectuer la même modification pour la classe CTimevalBase, dérivée en CTimeval, à laquelle est ajoutée la constante CstZero.

    Dans le fichier exo_02.cxx ajouter une nouvelle boucle en utilisant cette possibilité.

    Mettre à jour les fichiers Makefile, INCLUDE_H et MakeUtil.

    Compiler et tester.

Seconde amélioration

    Dans cet esprit, il est normal de doter de cette possibilité toute classe dont un représentant peut être considéré comme nul. C'est le cas de CTimespec et CTimeval. Il faut donc pouvoir écrire par exemple :
 

CTimespec Delai (5);     ... if (Delai) ...

    Le C++ offre pour cela une très élégante solution, qui consiste à définir dans ces classes l' opérateur de conversion en booléen.

    Après avoir introduit ces modifications dans les deux classes, ajouter une nouvelle boucle en utilisant cette possibilité, puis compiler et tester.

Corrigés : exo_02.cxx    -    Makefile    -    nsSysteme.h    -    nsSysteme.hxx    -    Time.h    -    Time.hxx    -    Time.cxx    -    INCLUDE_H    -    MakeUtil

Sommaire

Fonction alarm() - Timer

exo_03

• Notion de sablier (timer)
• Fonction système alarm()
• Liste des fichiers créés ou modifiés : exo_03.cxx

    Recopier le fichier exo_02.cxx dans exo_03.cxx. Ecrire la fonction ppal() qui :

• arme le sablier en appelant la fonction alarm() avec le délai passé en argument de la commande,
• attend dans la fonction pause() l'arrivée du signal,
• affiche un message de sortie.

    Dans l'espace de noms anonyme, écrire la fonction Chrono(), de profil :
 

void Chrono (ostream & os, const string & Msg, int Periode, int NbreCycles);

qui répète NbreCycles  fois la boucle formée de la séquence :

• attendre pendant Periode secondes au moyen de la fonction sleep().
• afficher le message Msg dans le flux os passé en paramètre,

    Dans ppal(), ajouter la séquence qui :

• réarme le timer à la première valeur,
• attend dans la fonction Chrono() l'arrivée du signal,
• affiche un message de sortie.

Corrigé : exo_03.cxx

Sommaire

Sablier cyclique

Classe CItimervalBase

• publique de la classe abstraite CEditable,
• protégée de la structure itimerval  (afin de masquer les données membres aux futurs utilisateurs).

• plusieurs constructeurs dont un par défaut,
• un destructeur virtuel,
• la fonction virtuelle protégée _Edit() (la classe est dérivée de CEditable) permettant d'afficher les objets sous la forme

[[xxx:xxx]:[xxx:xxx]]

• deux accesseurs GetDelai() et GetDelta()
• un modifieur Set() ayant 2 paramètres : le délai et l'intervalle (de type CTimevalBase)

Classes CTimer...

    Cependant, les trois timers fonctionnent de la même façon. Il est donc élégant de fournir un "modèle" de timer fournissant le prototype (classe abstraite). On ne peut pas parler ici de classe d'interface (réviser le cours de Java) car certaines des fonctions de la classe abstraite peuvent déjà être implémentées.

    Cette classe CTimerAbstr vous est fournie dans les fichiers CTimerAbstr.h et CTimerAbstr.hxx (à récupérer dans les chemins d'accès aux sources des corrigés).

    Obtenue par dérivation protégée de la classe CItimervalBase, elle fournit :

• un constructeur permettant d'initialiser les délais du timer,
• un destructeur virtuel,
• une fonction Set() permettant d'initialiser les délais du timer,
• une fonction Start() qui démarre le timer,
• une fonction Stop() qui l'arrête,
• une fonction GetTimer() qui récupère la valeur restante dans le champ it_value du timer d'Unix.

    De plus, aucune sorte de timer ne doit autoriser la duplication, tant par le constructeur par recopie que par l'opérateur d'affectation. Il suffit donc que la classe mère ne les autorise pas : les classes filles auront bien ces fonctions par défaut, mais toute tentative d'utilisation appellera les fonctions correspondantes de la classe mère, ce qui déclanchera une erreur de compilation.

    Dans les fichiers CTimer.h, CTimer.hxx et CTimer.cxx (répertoires include et util), créer les classes CTimerVirtual, CTimerProf et CTimerReal dérivées de CTimerAbstr. Lever une exception CException de code CstTropTimers = 143 pour toute tentative de création d'un timer déjà existant.

    Compléter les fichiers INCLUDE_H (macros CTIMERABSTR_H, CTIMERABSTR_HXX, CTIMER_H et CTIMER_HXX), MakeUtil (compilation de CTimer.cxx) et Makefile (ajout de CTimer.o).

Corrigés : CTimerAbstr.h     -     CTimerAbstr.hxx     -     CTimer.h     -     CTimer.hxx     -     CTimer.cxx     -     CstCodErr.h     -     INCLUDE_H     -     MakeUtil     -     Makefile

Sommaire

exo_04

• Utilité d'un destructeur virtuel.
• Nécessité de l'attribut volatile et du qualifieur sig_atomic_t (révision).
• Différence entre les délais des timers VIRTUAL et REAL.
• Liste des fichiers créés ou modifiés : exo_04.cxx

• dans la fonction ppal(), dérouter le signal SIGINT, dans le traitant duquel la variable globale volatile booléenne Fin, préalablement initialisée à false, est mise à true (stratégie E),
• dérouter les signaux SIGALRM et SIGVTALRM, dans les traitants desquels est affiché le signal reçu,
• créer dynamiquement les deux timers VIRTUAL et REAL initialisés tous les deux aux mêmes valeurs du délai et de l'intervalle, passées en argument de la commande,
• démarrer les deux timers, puis faire une boucle qui se termine lorsque Fin devient vrai,
• en sortie de boucle, essayer de créer un nouveau timer (VIRTUAL ou REAL) pour tester l'exception,
• détruire les deux timers par appels de la fonction Delete(),
• suspendre le programme pendant 3 secondes par sleep().

Corrigé : exo_04.cxx

Sommaire

Mesure de durées par un timer

Temps réel, temps virtuel

exo_05

• Liste des fichiers créés ou modifiés : exo_05.cxx

    Recopier le fichier exo_04.cxx dans exo_05.cxx. Ecrire la fonction ppal() qui :

• initialise les délais initiaux des deux timers REAL et  VIRTUAL au moyen de la même constante CTimeval, de valeur importante (par ex. 100 secondes), l'intervalle étant fixé à 0,
• démarre les deux timers,
• effectue la boucle,
• affiche en sortie de boucle le temps passé en mode user et le temps réel écoulé.

Corrigé : exo_05.cxx

Sommaire

Mode user, mode kernel

exo_06

    Recopier le fichier exo_05.cxx dans exo_06.cxx. Supprimer le namespace anonyme et son contenu, tout ce qui concerne les signaux et le traitement final de l'exception. Remplacer les timers dynamiques par des timers "automatiques". Remplacer le timer REAL par un timer PROF. Comme ci-dessus, initialiser les deux timers au moyen de la même constante CTimeval, de valeur importante (par ex. 100 secondes), l'intervalle étant fixé à 0.

    Remplacer la boucle par :

• une boucle effectuée NbreFois qui recopie le fichier Source dans le fichier Destination, octet par octet. Destination, Source et NbreFois sont passés en arguments de la commande,
• un affichage des temps passés en mode user et en mode kernel + user,
• une boucle effectuée NbreFois qui recopie le fichier Source dans le fichier Destination, par paquets de NbreOctets, passé lui aussi en argument de la commande.
• un affichage des temps passés en mode user et en mode kernel + user,

    Compiler et tester. Relancer plusieurs fois l'exécution et comparer les temps moyens des différentes opérations.

Remarques :

1. La granularité des timers est assez importante sur cette installation (de l'ordre de 10 ms). Donc des durées inférieures ne peuvent pas être mesurées. En conséquence, prendre un fichier source volumineux.
2. Il existe un moyen beaucoup plus simple d'obtenir ces informations, ainsi que beaucoup d'autres concernant le déroulement d'un processus, grâce à la fonction système getrusage(), que vous pouvez trouver dans le man correspondant.

Sommaire

Téléchargement des corrigés :

Chemins d'accès aux sources des corrigés :

[1] Il règne sous Linux une grande confusion dans la localisation dans les fichiers inclus des identificateurs concernant le temps :

• struct timespec est déclaré dans <time.h>. Or, le fichier <time.h> est un fichier standard du C, à ce titre remplacé en C++ par <ctime>. Le type timespec devrait donc faire partie de l'espace de noms std. Mais ce type n'est défini ni dans la norme du C ni dans celle du C++ !! En d'autres termes, le fichier <time.h> de Linux n'est pas conforme à la norme;
• struct timeval est déclaré dans <bits/time.h>, lui-même inclus dans <sys/time.h>,
• le fichier <time.h> est inclus lui aussi dans <sys/time.h>.

[2] le fichier <sys/time.h> comporte deux macros permettant de convertir des timeval en timespec et inversement.
 

#define TIMEVAL_TO_TIMESPEC(tv, ts) {                                   \         (ts)->tv_sec = (tv)->tv_sec;                                    \         (ts)->tv_nsec = (tv)->tv_usec * 1000;                           \ } #define TIMESPEC_TO_TIMEVAL(tv, ts) {                                   \         (tv)->tv_sec = (ts)->tv_sec;                                    \         (tv)->tv_usec = (ts)->tv_nsec / 1000;

Il contient aussi des macros de manipulation de timeval : timercmp, timeradd, timersub, etc...

[3] Rappel : une chaîne de caractères (NTCTS) peut être transformée en entier grâce à aux fonctions C atoi() ou strtol()

© D. Mathieu     mathieu@romarin.univ-aix.fr
I.U.T.d'Aix en Provence - Département Informatique