FR2769106A1 - Dispositif de compte-rendu de taches executees par un systeme informatique - Google Patents

Abstract

La présente invention concerne un dispositif de compte-rendu de tâches exécutées par un système informatique caractérisé en ce que, le système informatique (1), fonctionnant sous un système d'exploitation (2) ouvert " UNIX " disposant d'un fichier " Accounting " et un programme interface d'application SJR gui, met en oeuvre un procédé comportant les étapes suivantes :- exécution d'une commande racine sjr ayant pour argument la commande utilisateur TOTO avec sa liste d'arguments, la commande utilisateur constitue le processus dont on veut avoir le compte-rendu;- exécution d'un appel système (par exemple, IOCTL sous UNIX) permettant de créer un pseudo-terminal associé au processus TOTO à l'aide d'un attribut discriminant;- exécution d'un appel système permettant de créer un processus (par exemple, FORK sous UNIX) spécifiant en argument, la commande utilisateur TOTO à exécuter avec sa liste d'arguments, la commande utilisateur appelée TOTO étant un " script shell " comprenant des commandes standards et éventuellement, des commandes exécutables à créer par l'utilisateur et permettant la recherche dans le fichier " Accounting " grâce à l'attribut discriminant créé par l'appel système IOCTL, de l'heure de début et au temps de fin de l'exécution de la commande racine, de retrouver les enregistrements concernant la commande utilisateur appelée et ses processus fils.

Description

DISPOSITIF DE COMPTE-RENDU DE TACHES EXECUTEES PAR UN SYSTEME INFORMATIQUE
La présente invention concerne un dispositif de compte-rendu de tâches exécutées par un système informatique. Elle s'applique au domaine de l'exploitation informatique en environnement industriel et notamment aux systèmes informatiques de production de type ouverts fonctionnant sous des logiciels, par exemple, de type "UNIX" ou 'WINDOWS Nt'.

Ces serveurs, fonctionnant sous ce type de logiciels, sont des serveurs dits "ouverts" et sont particulièrement prisés de nos jours. Mais,
I'inconvénient de ces serveurs était d'avoir été développés pour des applications universitaires dont les préoccupations n'étaient pas identiques à celles des préoccupations industrielles.

En effet, sous "UNIX", il n'y a pas de conservation des traces d'exécution des tâches lancées par l'utilisateur. Une tâche (en anglais job) sous "UNIX" est un ensemble de commandes ou de processus lancés en série ou parallèle. Lorsque plusieurs tâches peuvent être lancées concurremment par différents utilisateurs, cela peut poser des problèmes, notamment de savoir où en est l'exécution d'une tâche.

Par ailleurs, s'il se produit un incident sur une tâche, il est nécessaire pour l'utilisateur qui a lancé cette tâche, de savoir quel est le type d'incident, pour pouvoir en expliquer les causes.

Les serveurs "UNIX" reconnaissent l'entité atomique "processus", qui est une unité d'exécution comprenant l'allocation de mémoire avec du code associé programme, une pile et l'ensemble des registres du processeur mais, il ne sait pas faire la correspondance entre plusieurs processus. Ces processus assurent d'une manière séquentielle, une fonctionnalité globale tels que par exemple, les commandes d'un "script shell", qui sont constituées d'une liste de commandes systèmes.

L'invention a donc pour but de fournir à un utilisateur, exécutant un travail complexe, impliquant l'exécution de plusieurs processus unitaires, un dispositif permettant un rapport d'exécution global offrant une description des ressources prises par l'exécution des étapes de ce travail et éventuellement, un compte-rendu des anomalies rencontrées pendant l'exécution de ce travail en faisant un lien entre tous les processus de ce job grâce à un pseudo-terminal (Pseudo-device).

Ce but est atteint par le fait que le système informatique, fonctionnant sous un système d'exploitation ouvert (par exemple, de type "UNIX"), disposant d'un fichier "Accounting" et d'un programme interface d'application, met en oeuvre un procédé comportant les étapes suivantes:
- exécution d'une commande racine SJR ayant pour argument la commande utilisateur TOTO avec sa liste d'arguments, la commande utilisateur constitue le processus dont on veut avoir le compte-rendu
- exécution d'un appel système (par exemple, IOCTL sous UNIX) permettant de créer un pseudo-terminal associé au processus TOTO à l'aide d'un attribut discriminant;
- exécution d'un appel système permettant de créer un processus (par exemple, FORK sous UNIX) spécifiant en argument, la commande utilisateur TOTO à exécuter avec sa liste d'arguments, la commande utilisateur appelée TOTO étant un "script shell" comprenant des commandes standards et éventuellement, des commandes exécutables à créer par l'utilisateur et permettant la recherche dans le fichier "Accounting" grâce à l'attribut discriminant créé par l'appel système (IOCTL), de l'heure de début et de fin, de l'exécution de la commande racine, de retrouver les enregistrements concernant la commande utilisateur appelée TOTO et ses processus fils.

Selon une autre particularité, le système comporte une interface graphique utilisateur (GUI) permettant d'afficher les enregistrements associés à la commande appelante et aux processus fils.

Selon une autre particularité, les processus fils, produits par la commande appelée, auront également pour héritage certaines caractéristiques de la commande appelante telles que l'attribut discriminant.

Selon une autre particularité, avant l'exécution de la commande appelante, le procédé mémorise l'heure de début.

Selon une autre particularité, à la fin de l'exécution de la commande appelante, le procédé mémorise l'heure de fin.

Selon une autre particularité, I'interface graphique utilisateur permet par l'affichage d'un menu, de sélectionner parmi les différentes composantes du menu à l'aide d'un moyen interactif entre l'utilisateur et l'écran, une des composantes du menu, par une mise en évidence de cette composante par rapport aux autres et de déclencher, par confirmation de cette sélection à l'aide d'un dispositif interactif, l'affichage d'une sélection d'informations correspondant aux composantes du menu sélectionnées.

Selon une autre particularité, la composante du menu permet d'afficher un historique des tâches.

Selon une autre particularité, une composante du menu permet d'afficher le "statut" (status) courant de l'une des tâches.

Selon une autre particularité, une de composantes du menu permet d'afficher les "statuts" (status) courants de toutes les tâches entrées.

D'autres particularités et avantages de la présente invention apparaîtront plus clairement à la lecture de la description ci-après faite en référence aux dessins annexés dans lesquels
la figure 1 représente une vue schématique du système informatique et des moyens logiciels associés au système informatique pour permettre la mise en oeuvre du procédé de l'invention;
la figure 2 représente une vue de la fenêtre affichée à l'écran lors de l'appel de l'interface graphique utilisateur;
la figure 3 représente une vue de l'écran affiché après sélection d'une des composantes du menu de la fenêtre précédente;
la figure 4 représente l'écran affiché aprés l'appel d'une autre composante du menu de la figure 2;
la figure 5 représente un autre écran après l'appel d'une autre composante du menu de la figure 2.

En préalable à la description d'un exemple de réalisation sous UNIX de l'invention, il est utile de rappeler les définitions ci-après.

Dans tout ce qui suit, le terme "processus" désignera tout exécution d'un programme (et par conséquent, en particulier, son environnement dans le système) à un instant donné, le programme constituant en lui-même, un objet inerte, rangé sur le disque sous la forme d'un fichier ordinaire exécutable. II est connu, dans les systèmes "UNIX", I'existence de deux types de processus:
~ les processus systèmes qui ne sont attachés à aucun terminal, qui sont créés au lancement du système ou à des dates fixées par l'administrateur du système et qui ne sont interrompus qu'à l'arrêt du système. Citons le "SWAPPER", un certain nombre de processus dits "démons" comme par exemple, le processus assurant le bon usage de l'imprimante en "SPOULE" ou le processus "CRON" qui permet de lancer des tâches à une date donnée.

- les processus lancés par un utilisateur particulier depuis un terminal donné à une date donnée. En particulier, le fait de se "loger" (en anglais log) sur un terminal sous une identification donnée, provoque le lancement d'un processus correspondant à l'exécution d'un fichier déterminé et à l'avance, pour chaque utilisateur. Ce type de processus correspond presque toujours à l'exécution d'un interprète d'un langage de commande (BOURNE shell ou C-shell). Pour information, nous rappellerons que l'utilisation de services standards par un usager est réalisée par l'intermédiaire de commandes qui nécessitent, pour fonctionner, I'existence de processus particuliers appelés "démons" sur la machine distante.

Le terme de tâche (job) désignera du point de vue de l'utilisateur une séquence d'opérations exécutées sans intervention de l'opérateur. Du point de vue du système, c'est un ensemble de processus connexe. Durant sa vie, une tâche (job) peut avoir un des trois états ci-après
- "ENTRE" (ENTERED) lorsque la tâche a été soumise mais pas encore démarrée, ce qui sera le cas tant que la tâche n'aura pas les ressources disponibles
- "DEMARRE" (STARTED) lorsque la tâche a débuté;
- "SUSPENDU" (HELD) lorsque la tâche a été "entrée" mais ne peut pas démarrer à cause de la suspension explicite de la tâche.

La structure du système "UNIX" représenté à la figure 1 est constitué des ressources matérielles d'un système informatique 1, lequel communique avec un noyau "UNIX" (KERNEL) 2 assurant la gestion de la mémoire et des entrées-sorties de bas niveau et d'enchaînement des différentes tâches.

Autour de ce noyau, sont utilisés un ou plusieurs "interpreteurs" de langage de commande "shell", un système de messageries et des programmes utilitaires dont évidemment un compilateur de langage C.

Autour de ces éléments classiques dans les systèmes "UNIX", ont été développés, pour les besoins des applications multitâches en environnement ouvert, deux modules de programme, I'un appelé service de compte-rendu de tâches SJR (Service Job Reporting) assurant les rapports d'exécution des tâches SJR lancées par un utilisateur, L'autre tâche facilité (job Facility) permettant de visualiser le bon déroulement, I'arrivée d'incidents, I'historique des tâches, le statut courant de l'une des tâches, le statut courant de toutes les tâches entrées et ainsi, de détecter les causes.

Pour les besoins de réalisation des rapports d'exécution de tâches, on rajoute, à ce système, une interface de programme d'application 44 effectuant le compte-rendu d'exécution de tâches. Cette application utilise d'une part, une interface graphique utilisateur 42 (SJR GUI) et d'autre part, communique avec un catalogue jor de compte-rendu des tâches à mémoriser dans un fichier distinct 5 du disque dur.

L'interface de programme d'application SJR 44 communique également avec le système standard 7 de compte-rendu de travaux des systèmes "UNIX" sous réserve qu'il soit activé et que les fichiers de compterendu de travaux soient mémorisés dans un fichier "Accounting" sur une partie 6 du disque dur de la machine en vue de leur exploitation par le service de compte-rendu de tâches 44.

La bibliothèque "SJR" 44 comporte des fonctions utiles pour permettre à l'utilisateur de gérer les tâches.

Ces fonctions font partie de l'interface programmatique et sont utilisables dans un code écrit en C
- une première fonction "SJRjobenter" vérifie que les paramètres de la tâche sont corrects, enregistre la tâche et attribue un identifieur de tâche,
- une seconde fonction "SJRjobstart" vérifié si la tâche peut démarrer et dans le cas contraire, attend jusqu'à ce que les ressources soient disponibles si le paramètre qflag est nul. Dans le cas ou qflag n'est pas nul, elle retourne immédiatement,
- une troisième fonction "SJRjobdelete" permet de libérer les entrées dédiées à la tâche dans les tables de gestion de tâches,
- une quatrième fonction "SJRjobinfoget" retrouve les entrées dédiées à la tâche dans les tables de gestion de tâches et copie ces informations dans une structure "jobinfo".

Les commandes disponibles grâce au module job Facility sont les suivantes
- une commande "SJR" qui permet de générer l'exécution d'un fichier de compte-rendu. Cette commande "SJR" correspond à du code en langage
C exécutant les étapes suivantes:
a) création d'un pseudo-terminal par un appel système
fd=open ("TOTO", mode) IOCTL (fd, arg)
"arg" est un argument tel que TIOSETTY corresponde à une option
de la primitive IOCTL.

Cette étape a associé un pseudo-terminal à un processus (TOTO)
b) enregistrement du temps initial et de la date de départ du
processus (TOTO);
c) exécution d'une primitive "FOURCHE" (FORK)
d) mise en attente de fin du processus (TOTO) en étant à l'écoute
des messages du système destinés au terminal et enregistrés dans
un fichier associé au pseudo-terminal par utilisation d'un appel
système "PIPE";
e) traitement, formatage du fichier "Accounting" et mise dans le
fichier de rapport associé au terminal.

- une commande "SJRlog" qui permet d'insérer des messages dans le compte-rendu;
- une autre commande "SJRinfo" qui fournit, à l'utilisateur, des informations au sujet d'une tâche ou de toutes les tâches. Une option à cette commande permet d'obtenir tous les processus courants de la tâche (job).

Une autre option permet d'afficher les informations tous les intervalles de temps définis par l'option;
- une commande "SJRwait" permet d'attendre la fin d'exécution de tous les travaux ayant été lancés en arrière-plan dans la même session.

L'utilisation de ces commandes se fait systématiquement avec l'utilisation d'une primitive "FOURCHE" (FORK) et d'une primitive "SORTIE" (EXIT), la primitive "FOURCHE" permettant la création dynamique d'un nouveau processus "fils", qui s'exécute de façon concurrente avec le processus dit "père, qui l'a créé. Ce nouveau processus "fils" étant une copie exacte du processus appelant "père". Ce nouveau processus ainsi créé, baptisé "processus fils", hérite du processus qui l'a créé (processus père), d'un certain nombre de ses attributs et comporte le même code, une compilation de données, I'environnement, la priorité, les différents prioritaires, les descripteurs de fichiers courants, le traitement des signaux.

Le seul moyen de distinguer le processus "fils" du processus "père" est que, dans le processus "fils" créé, la valeur de retour de la fonction "FORK" est zéro, alors qu'elle est égale, dans le processus "père", au numéro du processus "fils" nouvellement créé. L'utilisation des primitives "FOURCHE" et "SORTIE" est obligatoire de façon à attacher un pseudo-terminal au groupe de processus de la tache. Ainsi, par la procédure "FOURCHE" (FORK), le processus "fils" et tous les autres processus générés par le "fils" auront le même identificateur et, I'interface programme d'application SJR pourra facilement retrouver les éléments dans le fichier "Accounting" par cet identificateur de terminal associé. Les fonctions "SJR" figurant dans l'interface programmable sont utilisées, par exemple, de la façon suivante: intjobid
if (fork ())exit (0) ;T*Mandatory*/
jobid=SJRjobenter (getppid (), JOB~NAME , (char *)0)
if (jobid < 0) {
fprinff (stderr, SJRjobenter failed\n );
exit (jobid)
/*... fill structure SJRressources with values */
start=SJRjobstart (jobid, SJRressources, 0);
if (start < 0 ( fprinff (stderr, SJRjobstart failed\n ;
exit (start)
/*... Here is the User Work */
SJRjobdelete (jobid);
exit (0);
La primitive "FOURCHE" permet de créer un "fils" dont le "père" est indiqué dans la commande "SJRjobenter" par l'information "getppid" et, dont le nom est "JOB~NAME" qui sera le nom permettant de retrouver les fichiers et les informations nécessaires au groupe de processus.

Enfin, une commande "Cleanacct" permet à l'utilisateur de définir ses objectifs de réduction de la taille du fichier "Accounting" en éliminant les vieux enregistrements. Cette commande comporte les options suivantes définissables par les drapeaux ci-après
- h pour définir le nombre d'heures à conserver,
- m pour définir le nombre de nuits à conserver,
- n pour définir le nombre de jours à conserver,
- f pour définir le nom du fichier Accounting par exemple Madison accessible par le chemin var/adm/madison-acct.

Par ailleurs, par l'utilisation des commandes et des fonctions de l'interface de programme d'application SJR et, par l'utilisation de commande "UNIX", il a été développé une interface 42 graphique utilisateur SJR GUI.

Cette interface 42 permet à l'utilisateur, par action sur une souris, de déclencher des événements extérieurs traités par une interface préprogrammée susceptible de reconnaître ces événements, tels que par exemple, I'appui, le relâchement d'un bouton, la traîne et, des événements logiques tels que l'entrée du pointeur souris dans une fenêtre et de déclencher des traitements dans l'interface graphique 42 permettant, à partir du menu général représenté par la figure 2, de faire apparaître une fenêtre 421 comportant les différentes composantes d'un menu. Ce menu qui est constitué par les termes session, tâche, aide, permet de sélectionner dans ses composantes un élément d'un sous-menu associé à chaque composante, comme représenté dans le sous-menu par chacun des éléments. Un premier élément 4211 permet l'affichage de toutes les tâches un second élément 4212 permet l'affichage d'un historique ; un troisième élément 4213 permet l'affichage d'une seule tâche ; un quatrième élément 4214 permettant de suspendre les tâches, un cinquième élément 4215 permet de libérer les tâches ; un sixième élément 4216 permet d'annuler les tâches ; un septième élément 4217 permet d'avorter les tâches ; un huitième élément 4218 permet de forcer l'exécution d'une tâche. La sélection, à l'aide du curseur de la souris, de l'une de ces composantes du sous-menu, en mettant en surbrillance ou en évidence la composante sur laquelle le curseur souris est amené et, en validant cette sélection par l'enfoncement d'un bouton du dispositif de déclenchement des événements extérieurs (par exemple, souris), déclenche le traitement d'un processus par l'interface graphique 42 qui va permettre le contrôle des tâches selon le choix de l'utilisateur, d'avorter une tâche, d'afficher les tâches contrôlées par le système de reporting ou encore comme ci-après Cette présentation d'histogramme s'effectue par la sélection, sous forme de tableau historique dans une fenêtre 4211 qui comporte une première colonne permettant d'afficher l'heure, une deuxième colonne permettant d'afficher la date, une troisième colonne permettant d'afficher les processes exécutés, une quatrième colonne permettant d'afficher la dimension à laquelle appartient le processus, une cinquième colonne permettant d'afficher le nom de la commande associé au processus et une sixième colonne permettant d'afficher le "status" de la tâche à savoir si elle a été démarrée, achevée, avortée. Une dimension sera un jeu de processus couramment exécutés, qui auront la même importance, du point de vue du gestionnaire de ressources locales. Cinq dimensions sont prévues par défaut : une première dimension "SYSTEME", une deuxième dimension "LOt' (BATCH), une troisième dimension "DIVERS" (MISC), une quatrième dimension "Base de données" (DB) et une cinquième dimension "Traitement transactionnel " (TP). Si les processus sont lancés par les utilisateurs normaux directement en arrièreplan, ils appartiennent alors à la dimension "DIVERS". Si les processus sont lancés à travers un script, soumis à l'application de gestion des tâches sans aucune déclaration des dimensions explicites, ils appartiennent alors à la dimension "SYSTEME" Les dimensions "DB" et "TP" sont fournies mais sans aucune définition de processus et pourront être définies par l'utilisateur.

La sélection de la composante 4213 d'affichage d'une tâche permet à l'interface utilisateur d'afficher une fenêtre comportant une pluralité de pavés permettant chacun l'affichage d'informations alphanumériques, permet d'afficher dans le pavé A, I'identifieur de la tâche; dans le pavé B, le nom de la commande ; dans le pavé C, I'identifiant de l'utilisateur qui a soumis la tâche ; dans le pavé D, le "status" courant de la tâche ; dans le pavé E, le moment où la commande SJR a été entrée ; dans le pavé F, le moment où la tâche a été démarrée ; dans le pavé g, la consommation courante globale de CPU , dans le pavé H, le pourcentage de CPU consommé par la tâche dans le pavé I, la mémoire virtuelle requise ; dans le pavé J, le montant d'espace des fichiers temporaires requis ; dans le pavé K, le montant de mémoire réelle utilisée couramment; dans le pavé L, le montant de mémoire virtuelle utilisé couramment ; dans le pavé M, le montant de l'espace des fichiers temporaires couramment utilisé ; dans le pavé N, le nombre courant de processus, dans le pavé O, le plus grand nombre de mémoire réelle utilisée par la tâche, dans le pavé P, le plus grand nombre de mémoire virtuelle utilisée par la tâche ; dans le pavé Q, le plus grand montant d'espace de fichier temporaire utilisé par la tâche et dans le pavé R, le nombre maximum de processus N utilisé par le système pour cette tâche à un moment donné.

La sélection de la composante 4211 d'affichage de toutes les tâches dans le menu de la fenêtre 421 permet l'affichage de la figure 5 comportant dans un pavé, une première colonne a d'identification de la tâche, une deuxième colonne b donnant le nom de la tâche, une troisième colonne c dans laquelle figurent les utilisateurs, une quatrième colonne d donnant l'état de la tâche pour savoir si elle est démarrée ou entré et une cinquième colonne e donnant l'heure d'entrée de la tâche, une sixième colonne f pour l'heure de démarrage, une septième colonne g donnant les taux d'occupation du CPU, une huitième colonne h donnant les tailles de mémoire virtuelle et les fichiers temporaires requis, une neuvième colonne i subdivisée en quatre permet d'obtenir les tailles de mémoires réelles, de mémoire virtuelle utilisée ainsi que les tailles des fichiers temporaires et le nombre de processus, une dixième colonne j subdivisée en quatre permet de connaître les tailles maximales de mémoire réelle, de mémoire virtuelle, de fichier temporaire et de processus utilisés par la tâche.

On comprend ainsi l'intérêt de l'invention car elle permet, grâce à la commande "SJR", d'utiliser une machine "UNIX" comme un serveur d'entreprise, tout en ayant une conservation des traces d'exécution des tâches lancées, pour permettre de connaître les anomalies éventuelles, de façon par exemple, à être capable de déterminer lorsqu'on lance une tâche, qui sera exécutée la nuit lors de la fermeture des bureaux, que cette tâche sera achevée le matin avant l'arrivée du personnel.

D'autres modifications à la portée de l'homme de métier font également partie de l'esprit de l'invention. Ainsi, le dispositif et le procédé décrits, peuvent très-bien être utilisés et adaptés à tout autre type de système dit ouvert tel que, par exemple, "WINDOWS NTl.

Claims (9)

REVENDICATIONS

1. Dispositif de compte-rendu de tâches exécutées par un système informatique caractérisé en ce que, le système informatique (1), fonctionnant sous un système d'exploitation (2) ouvert (par exemple, de type "UNIX") disposant d'un fichier "Accounting" et un programme interface d'application

SJR gui, met en oeuvre un procédé comportant les étapes suivantes:

- exécution d'une commande racine sjr ayant pour argument la commande utilisateur TOTO avec sa liste d'arguments, la commande utilisateur constitue le processus dont on veut avoir le compte-rendu;

- exécution d'un appel système (par exemple, IOCTL sous UNIX) permettant de créer un pseudo-terminal associé au processus TOTO à l'aide d'un attribut discriminant

- exécution d'un appel système permettant de créer un processus (par exemple, FORK sous UNIX) spécifiant en argument, la commande utilisateur TOTO à exécuter avec sa liste d'arguments, la commande utilisateur appelée TOTO étant un "script shell" comprenant des commandes standards et éventuellement, des commandes exécutables à créer par l'utilisateur et permettant la recherche dans le fichier "Accounting" grâce à l'attribut discriminant créé par l'appel système IOCTL, de l'heure de début et au temps de fin de l'exécution de la commande racine, de retrouver les enregistrements concernant la commande utilisateur appelée et ses processus fils.

2. Dispositif de compte-rendu de tâches exécutées par un système informatique selon la revendication 1, caractérisé en ce que le système comporte une interface graphique utilisateur (42) permettant d'afficher les enregistrements associés à la commande appelant et aux processus fils.

3. Dispositif de compte-rendu de tâches exécutées par un système informatique selon la revendication 1 caractérisé en ce que, les processus fils produits par la commande appelée, auront également pour héritage certaines caractéristiques de la commande appelante telles que l'attribut discriminant.

4. Dispositif de compte-rendu de tâches exécutées par un système informatique selon la revendication 1 caractérisé en ce qu'avant l'exécution de la commande appelante, le procédé mémorise l'heure de début.

5. Dispositif de compte-rendu de tâches exécutées par un système informatique selon la revendication 1 caractérisé en ce qu'à la fin de l'exécution de la commande appelante, le procédé mémorise l'heure de fin.

6. Dispositif de compte-rendu de tâches exécutées par un système informatique selon la revendication 2, caractérisé en ce que, I'interface graphique utilisateur 42 permet par l'affichage d'un menu, de sélectionner parmi les différentes composantes du menu à l'aide d'un moyen interactif entre l'utilisateur et l'écran, une des composantes du menu par une mise en évidence de cette composante par rapport aux autres et de déclencher, par confirmation de cette sélection à l'aide d'un dispositif interactif, I'affichage d'une sélection d'informations correspondant aux composantes du menu sélectionnées.

7. Dispositif de compte-rendu de tâches exécutées par un système informatique selon la revendication 6 caractérisé en ce que, la composante du menu permet d'afficher un historique des tâches.

8. Dispositif de compte-rendu de tâches exécutées par un système informatique selon la revendication 6 caractérisé en ce qu'une composante du menu permet d'afficher le "statut" courant de l'une des tâches.

9. Dispositif de compte-rendu de tâches exécutées par un système informatique selon la revendication 6 caractérisé en ce qu'une des composantes du menu permet d'afficher les "statuts" courants de toutes les tâches entrées.