FR 2769105 A1 19990402 FR 9712146 A 19970930 1 2769105 DISPOSITIF ET PROCEDE DE PRISE EN COMPTE DE L'EXECUTION D'UNE TACHE SUR UN SYSTEME INFORMATIQUE La présente invention concerne un dispositif et un procédé de prise en compte de l'exécution d'une tâche sur un système informatique. Elle s'applique au domaine de l'exploitation informatique en environnement industriel et notamment aux systèmes informatiques de type "ouvert" fonctionnant sous des logiciels, par exemple, de type "UNIX" ou "WINDOWS NT". Les serveurs qui fonctionnent sous ce type de logiciels io sont des serveurs dits "ouverts" et sont particulièrement prisés de nos jours. L'inconvénient de ces serveurs est d'avoir été développés pour des applications universitaires dont les préoccupations n'étaient pas identiques à celles des préoccupations industrielles. Ainsi, sous un système d'exploitation "UNIX", les travaux, ou plus exactement chacun des processus composant des travaux se voient attribuer une priorité initiale, soit par le système, soit par l'utilisateur qui soumet ces travaux. Pour faire considérer un travail comme plus prioritaire par le système, il faut donc que l'utilisateur lui attribue explicitement une priorité initiale, ou vienne modifier manuellement sa priorité par une commande d'administration. Il n'y a donc aucune régulation ni inter- corrélation entre les niveaux de priorité que l'on attribue à tel ou tel travail. De même, dans un système "UNIX" classique, les processus peuvent démarrer sans aucune limitation, même sur les systèmes hautement chargés, sans aucune attention au montant de ressources, qui est couramment utilisé par les processus exécutés et sans aucune attention au montant de ressources que nécessitera le nouveau processus. Ceci conduit au mauvais comportement suivant: un paquet de processus est exécuté, les processus critiques aussi bien que les processus non critiques et les processus critiques, qui devraient être achevés à un temps souhaité par I'utilisateur disposent de trop peu de ressources pour être achevés au temps 2 2769105 souhaité. Dans un même temps, des processus non critiques utilisent trop de ressources. Un autre comportement inacceptable est celui o il n'y a pas suffisamment de fichiers temporaires libres et par conséquent, les écritures dans les fichiers échouent. Parfois, I'application contrôle cette condition d'erreur, parfois elle ne la contrôle pas et cela peut générer un comportement faux du fait que des fichiers incomplets sont générés par une étape dans un travail et traités dans des étapes ultérieures. Un autre comportement préjudiciable est celui o il n'y a pas assez d'espace de to pagination (PAGING SPACE) et le système prend la décision arbitraire de tuer le processus le plus récent sans considérer son importance. Ceci est inacceptable dans un environnement d'exploitation. C'est pourquoi le premier but de l'invention est de proposer un procédé de prise en compte de l'exécution d'une tâche qui permette de palier ces inconvénients. Ce but est atteint par le fait que le procédé de prise en compte de l'exécution d'une tâche sur un système informatique ouvert (par exemple, de type "UNIX") en fonction des ressources est caractérisé en ce qu'il comporte les étapes consistant: - a déterminer les ressources disponibles en mémoire virtuelle, mémoire réelle, espace fichiers temporaires, utilisation de temps d'unité centrale pendant le dernier intervalle de temps; - a calculer le montant des ressources préallouées aux autres requêtes et pas encore utilisées; - à comparer le montant de ressources requises pour l'exécution d'une tâche dont la requête a été présentée, au montant courant de ressources disponibles diminuées de la somme du montant des ressources préallouées aux autres requêtes pour déterminer en fonction du résultat de cette comparaison le lancement, I'ajournement ou le refus du lancement de la tâche requise. 3 2769105 Selon une autre particularité, le procédé comporte une étape consistant à définir le montant de ressources requises pour l'exécution d'une tâche par une commande spécifique. Selon une autre particularité, le procédé comporte une étape consistant à activer ou désactiver le mécanisme de détermination de la disponibilité suffisante de ressources systèmes. Un autre but de l'invention est de proposer un dispositif de prise en compte de l'exécution d'une tâche. Selon ce but, le dispositif de prise en compte de l'exécution d'une io tâche sous un système d'exploitation ouvert est caractérisé en ce qu'il comporte: -des moyens de déterminer les ressources disponibles en mémoire virtuelle, mémoire réelle, espace fichiers temporaires, utilisation de temps d'unité centrale pendant un intervalle de temps déterminé; - des moyens de calculer le montant des ressources préallouées aux autres requêtes mais pas encore utilisées; - des moyens de comparer le montant de ressources requises pour l'exécution d'une tâche dont la requête a été présentée, au montant courant de ressources disponibles diminué de la somme du montant des ressources préallouées aux autres requêtes; - et des moyens de commander le lancement, I'ajournement ou le refus du lancement de la tâche requise en fonction du résultat fourni par les moyens de comparaison. Selon une autre particularité, le dispositif comporte comporte un moyen de définir le montant de ressources requises pour l'exécution d'une tâche par une commande spécifique. Selon une autre particularité, le dispositif comporte un moyen d'activer ou désactiver le mécanisme de détermination de la disponibilité suffisante de ressources systèmes. 4 2769105 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 un exemple de situation dans la gestion des ressources selon l'invention; En préalable à la description d'un exemple de réalisation sous UNIX to de l'invention, il est utile de rappeler les définitions ci-après. Dans tout ce qui suit, le terme "processus" ou "tâche" désignera toute 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 un disque sous la forme d'un fichier ordinaire exécutable. Il est connu, dans les systèmes "UNIX", l'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 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 également que l'utilisation de services standards par un usager est réalisée sur une machine distante par 2769105 l'intermédiaire de commandes, qui pour fonctionner sur la machine distante, nécessitent l'existence de processus particuliers appelés "démons". 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 (job). 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 "api" de programme, I'un (SJR Service Job Reporting) assurant les rapports d'exécution des tâches lancées par un utilisateur, I'autre (LRM) permettant de visualiser le bon déroulement ou lI'arrivée d'incidents et ainsi, de détecter les causes. Ce premier module sera appelé service de compte- rendu de tâches "SJR" (Service Job reporting) et l'autre se nommera "LRM" (Local Ressource Management) module de gestion locale des ressources. A cela, il a été ajouté pour les besoins de l'invention, un démon (daemon) 3 de management local des ressources qui communique d'une part, avec le noyau 2 et d'autre part, avec une interface de programme d'application 34. Ce démon (daemon) 3 communique également avec un fichier 33 de configuration LRM 33, mémorisé dans le disque dur et avec une interface graphique utilisateur (LRM gui) associée 32 (Graphic Uper Interface). L'interface d'application de programme d'application 34 communique d'une part, avec le démon 3 et d'autre part, avec une mémoire partagée 31. Cette mémoire partagée est également en communication avec l'interface graphique utilisateur 32 et le démon 3. Pour les besoins de la préallocation, le système incorpore une interface 44 de programme d'application "SJR" effectuant le compte-rendu d'exécution de tâches (Service Job Reporting). Cette application 44 communique avec un 6 2769105 catalogue "jor" mémorisant dans un fichier distinct 5 du disque dur le compte-rendu des tâches. Cette interface 44 de programme d'application communique, sous réserve qu'il soit activé et que les fichiers de compte- rendu de travaux soient mémorisés, avec le démon 34 de gestion locale des ressources pour permettre la préallocation de ressources et la régulation dynamique. L'interface 44 comporte les lignes de codes nécessaires pour permettre l'exécution des commandes disponibles pour l'utilisateur grâce à cette interface. Les commandes disponibles par cette interface 44 sont les suivantes: to - une commande "SJR" qui permet d'émettre une commande au gestionnaire de ressources et de générer l'exécution d'un fichier de compte- rendu. Cette commande figurant en annexe 1 comporte plusieurs options qui permettent de déterminer le nombre de pages de mémoire virtuelle, la quantité d'espace des fichiers temporaires, les dimensions définies par les utilisateurs, la consommation de temps attendu par le CPU, le temps maximum écoulé, le temps maximum CPU, I'espace maximum pour les fichiers temporaires, le nombre maximum de pages de mémoire virtuelle. Cette commande figure en annexe 1 de la description avec la signification de ces différents paramètres. - une commande "SJRjobstart" (int jobid int qflag struct SJR_resources *SJR_resources;), dans laquelle le paramètre jobid est l'identifieur de tâche, SJR resources est la structure décrivant les ressources nécessitées pour la tâche. Cela peut être O si la tâche n'a pas besoin de préallocation de ressources. Le paramètre "qflag", lorsqu'il est nul, signifie que la tâche attendra la disponibilité des ressources. Cette commande vérifie que la tâche peut démarrer, si elle ne peut pas démarrer, le système attend jusqu'à ce que les ressources soient disponibles, ceci est le cas lorsque "qflag" est nul. Si "qflag" n'est pas nul, cela provoque un retour immédiat. Si la tâche peut démarrer, une valeur O est renvoyée sinon lorsque "qflag" est positionné, une valeur -1 est renvoyée. De plus, chaque événement majeur d'une tâche est mémorisé lorsqu'il se produit dans un 7 2769105 fichier global "logc" du catalogue "jor". Ce fichier peut être visualisé par la commande "sjr log file" qui permet l'affichage des paramètres p, t, d, c, e, C, P, T ci-après définis. De façon à éviter de définir explicitement les paramètres pour chaque soumission de tâche, I'application "SJR" 44 fournit la faculté de déclaration de ressources dans un script. Ainsi, quand le développeur d'une application a bien défini les nécessités de ressources pour sa tâche, il pourra insérer celle-ci dans le script. La tâche sera soumise par la commande "SJR" avec aucun autre paramètre. La syntaxe pour ces lignes de directive est la suivante: #option -p "Nombre de pages de mémoire virtuelle" #option -t "Montant d'espace de fichiers temporaires" #option -d "Fonction définie par l'utilisateur" #option - c "Temps CPU attendu" #option - e "Temps maximum écoulé" #option - C "Limite de temps CPU consommé" #option - P "Nombre maximum de pages mémoire virtuelle" #option - T "Espace fichiers temporaires maximum" En cas de conflit, la valeur spécifiée à la soumission de la commande est utilisée ainsi: s'il y a une ligne à l'intérieur du script telle que #option - C 200 et si le script est soumis avec la ligne de commande suivante: SJR -C 300 script, alors la valeur utilisée pour la limite CPU est 300. Avec un système ainsi équipé du module de gestion locale de ressources, les processus non critiques devraient altérer le moins possible la poursuite de l'exécution des processus critiques. Chaque sorte de processus a sa propre importance. On devrait lui accorder plus ou moins de ressources en fonction de cette importance et en fonction de la charge du système. Pour cette raison, le module "LRM" permet de classifier les processus en dimension. Une dimension sera un jeu de processus couramment exécutés, qui auront la même importance, du point de vue du 8 2769105 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ère-plan, 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 deuxième dimension "LOT" (BATCH). Si les processus n'appartiennent à aucune autre dimension, 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. A l'exception de la dimension "SYSTEME", il sera possible pour chaque dimension, d'avoir un poids relatif, qui sera mémorisé dans un fichier. Ce poids relatif sera utilisé pour gérer la priorité des processus composant la dimension. La priorité de tous les processus appartenant à une dimension, variera de la même façon. La dimension "SYSTEME" n'a pas de poids relatif et les priorités des processus appartenant à cette dimension ne sont pas modifiées par le gestionnaire de ressources locales (LRM). Les processus, régulés par les dimensions, auront toujours des ressources accordées en fonction de leur poids relatif, même si le système est très chargé. Au moment du lancement du gestionnaire de ressources locales, ou lorsqu'une dimension est créée, sans préciser de poids relatif, cette dimension prend un poids de - 1 par défaut, ce qui veut dire qu'elle existera, mais elle ne sera pas régulée. Une dimension peut également être activée ou désactivée. Si elle est désactivée, les tâches soumises lui appartenant ne seront pas démarrées, mais les tâches, qui sont en cours d'exécution dans cette dimension, continueront à être exécutées. Lorsqu'un processus résulte d'une commande d'exécution d'une tâche "SJR", il appartient à la dimension spécifiée, si une dimension a été 9 2769105 spécifiée dans la commande "SJR". Lorsque le processus a un ancêtre dont le nom de commande et l'utilisateur sont associés à une dimension, le processus appartient à cette dimension. Pendant le temps d'exécution d'un processus, le poids relatif sera utilisé pour gérer et modifier la priorité des processus composant la dimension. Un processus préalloué n'est soit pas lancé par sjr soit ne comporte pas de paramètres de préallocation. Grâce à l'application de gestion de ressources, I'utilisateur ainsi que le gestionnaire de ressources connaîtront pour chaque ressource à un temps donné, combien de ressources sont actuellement utilisées et combien io de ressources sont déclarées pour chaque tâche. Ainsi, dans l'exemple représenté à la figure 2, u" représente les ressources utilisées par les processus non préalloués. Ra représente le montant des ressources libres, réservées pour les processus administratifs et systèmes. U1, U2 représentent les ressources utilisées par les tâches 1 et 2. D1 et D2 i, représentent les ressources déclarées pour les tâches 1 et 2. R1 représente la différence entre Dl et U1. R2 représente la différence entre D2 et U2, Af représente les ressources considérées comme disponibles par le gestionnaire de ressources. Si une tâche est soumise et déclare un montant de ressources D3 nécessaires, elle ne démarrera que si Af est supérieur à D3. On comprend ainsi, I'intérêt de l'allocation préalable de ressources pour ne permettre le lancement d'une tâche, que lorsque le minimum de ressources nécessaires est disponible. Le mécanisme de préallocation de mémoire virtuelle et d'espace de fichiers temporaires est mis en oeuvre par une commande "SJR" constituant également un processus qui contribue au bon fonctionnement du système. Quand une tâche est soumise, elle peut demander par la commande SJR un certain montant de ressources. Le gestionnaire de ressources essaie alors de s'assurer qu'il y a suffisamment de ressources pour la tâche. Les tâches peuvent être soumises avec des options, une première, qui est de fournir un temps maximum écoulé et une seconde, qui est le temps total attendu 2769105 d'unité centrale pour la tâche. Quand une requête de ressources est examinée, les valeurs suivantes sont considérées: - le montant de ressources requises "r"; - le montant courant de ressources disponibles "A"; - les ressources déjà préallouées aux autres requêtes, mais pas encore utilisées "R"; - un montant initial de ressources "Ra" déclaré au départ par l'utilisateur au gestionnaire de ressources pour aider à prévenir les avortements dus à l'allocation de ressources incontrôlées. to Le montant courant de ressources "A" est une information obtenue périodiquement et mise à jour périodiquement par le "démon" LRM en vérifiant les tables d'informations systèmes qui sont mémorisées. La valeur des ressources déjà préallouées "R" est aussi déterminée par le "démon" LRM, qui rassemble les utilisations courantes de ressources par les tâches. "Ra" est une valeur fixée, fournie par le "démon" LRM comme étant l'un de ces arguments. La requête sera satisfaite si r en tenant compte de l'évolution de sa priorité. Les annexes qui suivent concernent les parties de code permettant de calculer la mémoire totale virtuelle et la mémoire réelle disponible. Ce calcul est effectué par la partie de code ci-dessous. 25... Computing Available and Total Virtual and Real Memory. /* get_vmdata: Obtention of information on Available real and Virtual Memory */ get_vmdata(vm) struct vmdata *vm; { char buff[1024]; int bufsiz = 1024; char wl [20], w2[20], w3[20], w4[20]; while (1) { h11 2769105 int vl, v2; if (!init accesstocommands done){ /* Initialization: Command vmstat is launched, and its output caught; La commande vmstat est lancée et sa sortie capturée*/ init accessto _commandsdone = 1; initaccesstocommands(); fdvmcom = sag_popen_getline("vmstat 1", buff, &bufsiz, 2); } else { int cr; to /*A new line issued by command vmstat is read; Une nouvelle ligne émise par la commande vmstat est lue*/ cr = sag_popen_nextline(fdvmcom, buff, &bufsiz, 2); if (cr ≤ 0) { fdvmcom = sag_popen_getline("vmstat 1", buff, &bufsiz, 2); } } /* line is examined and information recuperated; La ligne est examinée et l'information récupérée*/ sscanf(buff, "%s %s %s %s", wl, w2, w3, w4); if (!strcmp(wl, "kthr") &&!strcmp(w2, "memory")) continue; if (!strcmp(wl, "----") &&!strcmp(w2, "----")) continue; if (!strcmp(wl, "r") &&!strcmp(w2, "b")) continue; sscanf(w3, "%d", &vl); sscanf(w4, "%d", &v2); vm->totrealmem = vmconstant.totrealmem; /* System Call psdanger returns Total Virtual Memory and Available Virtual Memory; Appel système psdanger retourne la mémoire virtuelle totale et disponible*/ vm->totvirtmem = psdanger(0) *4; vm->avrealmem = v2 * 4; vm->avvirtmem = psdanger(-1) * 4; return (0); } Le processus comporte également une étape de calcul de l'espace de fichiers temporaires total et disponible. Cette étape de calcul est exécutée par la partie de code ci-après. Computing Available and Total Temporary File Space: updtmpspace(avtmpspace, tottmpspace) int *avtmpspace; int *tottmpspace; 12 2769105 { int curnbtmpdev; char *ptdevlist; int i; struct statfs statfsbuf; curnbtmpdev = enum_dev(); if (curnbtmpdev > nbtmpdev) { nbtmpdev = curnbtmpdev; if (tmpdevlist) (unsigned char *) free(tmpdevlist); tmpdevlist = (char *) malloc(nbtmpdev * 200); tmpdevno = (int *) malloc(nbtmpdev * sizeof(int)); } ts if (curnbtmpdev > 0) { getdev(tmpdevlist, tmpdevno); *avtmpspace = 0; *tottmpspace = 0; for (i = 0, ptdevlist = tmpdevlist; i 200) { int cr; /* System Call ststfs provides informations on the File System; Appel système ststfs fournit les informations sur le fichier système*/ cr = statfs(ptdevlist, &statfsbuf); /* conversion en Kb: multiplier par 4 */ *avtmpspace += 4 * staffsbuf. f_bfree; *tottmpspace += 4 * staffsbuf.f_blocks; } } Puis, on détermine également l'usage d'unité centrale effectué pendant le dernier intervalle de temps et cette détermination est faite à l'aide la partie de code ci-après. /* sysinfo and vminfo are AIX Kernel tables;sysinfo et vminfo sont des tables du noyau AIX*/ *function get sysinfo and_vminfo reads these table from the Kernel *Memory;la fonction get.sysinfoetvminfo lit les tables de la mémoire du noyau*/ getsysinfo_and_vminfo (&sysinfo, &vminfo); tpgspgouts = (double) (vminfo.pgspgouts ovminfo.pgspgouts)/(double) Irmdinterval; 13 2769105 trunque = (double) (sysinfo.runque - osysinfo.runque)/(double) Irmdinterval; tswpque = (double) (sysinfo.swpque-osysinfo. swpque)/(double) Irmdinterval tuser = (double) (sysinfo.cpu[CPU_USER]) /(double) Irmdinterval tsystem = (double) (sysinfo. cpu[CPU_KERNEL]- osysinfo.cpu[CPUKERNEL])/(double) Irmdinterval; tidle = (double) (sysinfo.cpu[CPU_IDLE]-osysinfo.cpu[CPU_IDLE]- o10 /(double) Irmdinterval; twait = (double) (sysinfo.cpu[CPU_WAIT]- osysinfo.cpu[CPU_WAIT])/(double) Irmdinterval; tsum = tuser + tsystem + tidle + twait; Le processus comporte également une étape de détermination des espaces préalloués mais pas encore utilisés par les tâches. Cette étape est effectuée par la partie de code ci-après. Computing Prealloc space not used by jobs: shmem->system. preallocvirtmem = 0; shmem->system.prealloctmpspace = O; for (job = shmem->firstjb_started; job; job = job->next) { if (job->requiredvirtmem && (job->requiredvirtmem > job- >currentvirtmem)) { shmem->system.preallocvirtmem += (job->requiredvirtmem - job->currentvirtmem); } if (job->requiredtmpspace && (job->requiredtmpspace > job- >currentusedtmpspace)) shmem->system.prealloctmpspace += (job- >requiredtmpspace - job->currentusedtmpspace); } L'évaluation effectuée selon la formule R la partie de code ci-après. Checking Resources for a job: LRMresourcescheck(LRMresources) 14 2769105 struct LRMresources *LRMresources; { struct timeval tv; struct timezone tz; struct systementry system; gettimeofday(&tv, &tz); shmgetsystem(&system); if (LRMresources->requiredtmpspace > (system. avtmpspace - 35 0o system.prealloctmpspace - system.reservedtmpspace)) J return (0); if (LRMresources->requiredvirtmem > (system.avvirtmem - 36 system.preallocvirtmem - system.reservedvirtmem)) return (0); if (LRMresources->expectedtermination) { int remains; int tl; double a, b; remains = LRMresources->expectedtermination - tv. tv_sec; LRMresources->neededratecpu = 100.0 * LRMresources- >expectedcpu / remains; 37 /* * tester ici avec le taux de cpu disponible courant *1 LRMdbgprintf(DBGALL, "Maximum Ellapse specified\n"); LRMdbgprintf(DBGALL, "Remains: %d\n", remains); LRMdbgprintf(DBGALL, "Needed Rate of CPU: %f\n", LRMresources->neededratecpu); LRMdbgprintf(DBGALL, "Extrapolated Available Rate of CPU: %d\n", system.workingavcpu); if (remains > 0 && LRMresources->neededratecpu ≤ system.workingavcpu) { LRMdbgprintf(DBGALL, "Rate of CPU is good enough\n"); return (1); }else{ LRMdbgprintf(DBGALL, "Rate of CPU is too low\n"); if (remains neededratecpu > 100.0 * system. nbprocessors) { LRMdbgprintf(DBGALL, "There will not be enough free CPU to complete the job in time\n"); 38 return (-1); } return (0); } }else return (1); I 2769105 Dans cette partie de code, la portion 35 effectue l'évaluation de la partie espace temporaire et retourne la valeur O si l'espace temporaire suffisant est disponible. Puis le processus se poursuit par une évaluation sur la partie mémoire virtuelle effectuée par la portion 36 qui retourne la valeur O si l'espace mémoire virtuelle suffisant est disponible. Enfin, le système effectue l'évaluation des ressources CPU disponibles par la partie de code 38. Cette évaluation est faite après avoir déterminé d'une part, les ressources restantes (REMAINS) et le taux CPU nécessaire (NEEDED RATE CPU). Si le taux d'unité centrale disponible est suffisant, le système io retourne à la valeur 1, ce qui permet l'exécution de la requête alors que dans le cas o le système retourne à la valeur - 1, la requête de l'exécution de la tâche est ajournée. Ainsi, par la définition des paramètres nécessaires à l'exécution d'une tâche entrée au préalable dans la commande SJR par l'utilisateur, celui-ci pourra par utilisation du mécanisme décrit précédemment déclencher l'exécution d'une tâche sur le système, lorsque celle-ci disposera des ressources nécessaires à sa bonne exécution. Toute modification à la portée de l'homme de métier fait également partie de l'esprit de l'invention. Ainsi, le procédé et le dispositif décrits, peuvent facilement être utilisés et appliqués avec un autre système ouvert tel que, par exemple, "WINDOWS NT". ANNEXE 1 NAME: sjr command sjr - submits a command to the resource manager and generates an execution report in a file SYNOPTIQUE sjr [ -p 16 2769105 [-t ] [-c - e ] [-T ] [-P ] [-rOI 11 21 3] [-v = ]... [command args...] 17 2769105 REVENDICATIONS 1. Procédé de prise en compte de l'exécution d'une tâche sur un système informatique ouvert en fonction des ressources caractérisé en ce qu'il comporte les étapes consistant: - à déterminer les ressources disponibles en mémoire virtuelle, mémoire réelle, espace fichiers temporaires, utilisation de temps d'unité centrale pendant le dernier intervalle de temps; - à calculer le montant des ressources préallouées aux autres requêtes et pas encore utilisées; - à comparer le montant de ressources requises pour l'exécution d'une tâche dont la requête a été présentée, au montant courant de ressources disponibles diminuées de la somme du montant des ressources préallouées aux autres requêtes pour déterminer en fonction du résultat de cette comparaison le lancement, I'ajournement ou le refus du lancement de la tâche requise. 2. Procédé selon la revendication 1, caractérisé en ce qu'il comporte une étape consistant à définir le montant de ressources requises pour l'exécution d'une tâche par une commande spécifique. 3. Procédé selon la revendication 1 ou 2, caractérisé en ce qu'il comporte une étape consistant à activer ou désactiver le mécanisme de détermination de la disponibilité suffisante de ressources systèmes. 4. Dispositif de prise en compte de l'exécution d'une tâche sur un système d'exploitation ouvert caractérisé en ce qu'il comporte: - des moyens de déterminer les ressources disponibles en mémoire virtuelle, mémire réelle, espace fichiers temporaires, utilisation de temps d'unité centrale pendant un intervalle de temps déterminé; 18 2769105 - des moyens de calculer le montant des ressources préallouées aux autres requêtes mais pas encore utilisées; - des moyens de comparer le montant de ressources requises pour l'exécution d'une tâche dont la requête a été présentée, au montant courant de ressources disponibles diminué de la somme du montant des ressources préallouées aux autres requêtes; - et des moyens de commander le lancement, I'ajournement ou le refus du lancement de la tâche requise en fonction du résultat fourni par les moyens de comparaison. 5. Dispositif selon la revendication 4, caractérisé en ce qu'il comporte un moyen de définir le montant de ressources requises pour l'exécution d'une tâche par une commande spécifique. 6. Dispositif selon la revendication 4 ou 5, caractérisé en ce qu'il comporte un moyen d'activer ou désactiver le mécanisme de détermination de la disponibilité suffisante de ressources systèmes.