FR2812099A1 - Procede et dispositif d'autoregulation, dans un systeme informatique, de la consommation de ressources informatiques par un logiciel - Google Patents

Abstract

L'invention concerne l'autor egulation, dans un système informatique (SYS), de la consommation d'au moins une ressource physique (MEM2) et/ ou logicielles par au moins un processus (srv1, proc1, srv2, proc2). Le système comprend au moins un agent AGM dot e de moyens de mesure de la consommation d'au moins une ressource en fonction du temps. L'invention consiste- à pr edire, par l'interm ediaire d'une m ethode d'approximation, l' evolution de la consommation de tout ou partie des ressources (MEM2) en fonction de mesures effectu ees,- à identifier le (ou les) processus le (s) plus gros consommateur (s) de ressources,- et à lancer, eventuellement, une action en fonction d'au moins une condition de seuil (CS1, CS2) associ ee et pr ealablement d efinie.

Description

I 2812099

Titre: Procédé et dispositif d'autorégulation, dans un système informatique,

de la consommation de ressources informatiques par un logiciel.

DESCRIPTION

Domaine technique -

La présente invention a pour objet un procédé et un dispositif d'autorégulation de la consommation de ressources informatiques par un logiciel dans un système informatique. Le procédé d'autorégulation concerne plus particulièrement un procédé et un dispositif permettant la détection d'une consommation anormale de ressources informatiques par un logiciel, et le

lancement d'actions correctrices adaptées.

Le système informatique peut être un système dont l'environnement est de type distribué ou local. Rappelons, qu'un système informatique dont l'environnement est de type distribué est un environnement qui fonctionne au moyen d'au moins deux systèmes d'exploitation reliés entre eux par l'intermédiaire d'un réseau de type local de type LAN (Local Area Network) ou à grande distance de type WAN (Wide Area Network) ou internet. D'un autre côté, un système informatique dont l'environnement est de type local est un système informatique

qui fonctionne au moyen d'un seul système d'exploitation.

Les ressources informatiques concernées peuvent être de tout type (matérielles ou logicielles). Une ressource peut être un espace de fichier d'un disque ou d'une partition de ce disque, la taille de mémoire prise par l'exécution d'un logiciel, le nombre de processus, etc. Etat de la technique Avant la présentation de l'invention, il est souhaitable de préciser certains

concepts de base, comme ceux de programme, de processeur et de processus.

On définit un programme comme une suite statique d'instructions.

Un processeur peut être défini comme l'agent qui exécute les instructions

d'un programme.

Un processus est une action, une séquence d'opérations qui se déroule

pour réaliser un travail (ou tâche) déterminé(e); c'est un programme en exécution.

Par opposition à la staticité du programme, on introduit avec le processus, une

entité dynamique.

De façon générale, on peut définir une ressource comme un élément nécessaire à un processus pour mener à bien son exécution. Les ressources matérielles d'un système informatique (CPU, mémoires, dispositifs d'entrée/sortie, etc.), sont disponibles en quantité limitée et doivent être partagées entre les différents processus. Des logiciels ou des fichiers, dans la mesure o ils peuvent

1o être partagés, font aussi partie des ressources que le système doit gérer.

Les mécanismes d'allocation d'une ressource particulière sont réalisés dans les différentes couches du système d'exploitation. Par exemple, I'allocateur (ou dispatcher) décide de I 'allocation du CPU, et l'allocation d'un fichier à un

processus est implanté au niveau de la gestion des fichiers.

Plus précisément, les objectifs de la couche propre à l'allocation des ressources sont: - assurer une bonne utilisation des ressources. Comptabiliser et fournir des statistiques sur l'exploitation des ressources; - créer de nouveaux processus et leur attribuer le niveau de priorité approprié; - permettre à chaque processus existant dans le système d'obtenir les ressources nécessaires dans les limites de temps raisonnable; - exclure mutuellement les processus qui demandent une même

ressource non partageable et éviter les situations de blocage.

Le processus système ayant pour charge ces objectifs s'appelle le

planificateur (scheduler).

Lors de l'exécution d'un travail T1 sur un système informatique, il peut arriver que ce travail ne puisse se terminer correctement, ou bien soit bloqué parce que l'exécution d'un autre travail T2 entraîne la consommation excessive

d'une ressource partagée entre T1 et T2.

Le gros problème est qu'il n'existe pas de moyens techniques donnant la

possibilité de prévoir d'éventuels problèmes lors de l'exécution d'un programme.

Actuellement, la détection de problèmes de ce type passe par l'utilisation de commandes standards de type UNIX, ainsi que par un travail de dépistage. Les outils standards sont d'ailleurs insuffisants à eux seuls dans certains cas. Par exemple, un fichier qui grossit de façon extravagante ne peut être identifié automatiquement; une telle détection demande un travail d'expertise et d'intuition de la part de l'homme du métier basées sur la connaissance du fonctionnement

des applications.

L'invention Un premier but de l'invention est de pouvoir anticiper automatiquement les problèmes liés à la consommation excessive de certaines ressources lors de

l'exécution d'un programme.

Un deuxième but est de lancer des actions correctrices automatiquement

de façon à réduire cette consommation excessive.

A cet effet, la solution a pour objet un procédé d'autorégulation, dans un système informatique, de la consommation d'au moins une ressource physique eVt/ou logicielles par au moins un processus, ledit système comprenant au moins un agent doté de moyens de mesure de la consommation d'au moins une ressource en fonction du temps, caractérisé en ce qu'il consiste, pour l'agent, - à prédire, par l'intermédiaire d'une méthode d'approximation, I'évolution de la consommation de tout ou partie des ressources en fonction de mesures effectuées, - à identifier le (ou les) processus le(s) plus gros consommateur(s) de ressources, - et à lancer éventuellement une action en fonction d'au moins une

condition de seuil associée et préalablement définie.

Il en résulte un agent pour l'autorégulation de la consommation d'au moins une ressource physique et/ou logicielles par au moins un processus (srvl, procl, srv2, proc2), ledit agent étant doté de moyens de mesure de la consommation d'au moins une ressource en fonction du temps, caractérisé en ce qu'il comprend - des moyens de prédiction de l'évolution de la consommation de tout ou partie des ressources (MEM2) en fonction de mesures effectuées, - et des moyens de lancement d'au moins une action en fonction d'au moins une condition de seuil associée et préalablement définie dans une mémoire informatique,

pour la mise en oeuvre du procédé tel que défini précédemment.

La solution concerne également le système informatique mettant en oeuvre le procédé défini précédemment, le système comprenant au moins une io ressource physique et/ou logicielle, au moins un processeur, au moins un processus utilisant ladite au moins une ressource pour mener à bien son exécution, ledit système comprenant au moins un agent doté de moyens de mesure de la consommation d'au moins ladite ressource en fonction du temps, caractérisé en ce que l'agent comprend: - des moyens de prédiction de l'évolution de la consommation de tout ou partie des ressources (MEM2) en fonction de mesures effectuées, - et des moyens de lancement d'au moins une action en fonction d'au moins une condition de seuil associée et préalablement définie dans

une mémoire informatique.

L'invention sera mieux comprise à la lecture de la description qui suit

donnée à titre d'exemple et faite en référence aux dessins annexés.

Dans les dessins: - la figure 1 est une vue schématique partielle illustrant un système

informatique connu sur laquelle peut s'appliquer le procédé conforme à l'invention.

- la figure 2 est une vue schématique d'un graphe illustrant des mesures

du taux de consommation d'une mémoire du système informatique.

- la figure 3 est un algorithme illustrant les différentes étapes du procédé

d'autorégulation du procédé conforme à l'invention.

Pour simplifier la description, dans les dessins les mêmes éléments

portent les mêmes références.

Description d'un exemple de réalisation:

Sur la figure 1, on a représenté un système informatique SYS incluant au moins une machine comprenant au moins une ressource physique et/ou logicielle, par exemple un processeur, une mémoire temporaire, un disque dur, etc. Si le système comprend au moins deux machines, celles-ci sont reliées entre elles par l'intermédiaire d'un réseau quelconque non représenté sur la figure. De manière à

simplifier l'exposé de l'invention, on se limitera à une seule machine MAC.

Naturellement, I'invention s'applique à un système informatique dont le nombre de

0o machines peut être quelconque.

Rappelons que dans un système informatique, il existe trois catégories d'utilisateurs: - le propriétaire d'une ressource, - le groupe d'utilisateurs auquel appartient le propriétaire que l'on nomme groupe propriétaire,

- les autres utilisateurs, c'est-à-dire tout le monde.

Sur la machine MAC, I'exécution d'un programme donne naissance à des processus (srvl, procl, srv2, proc2) qui réalisent chacun un travail déterminé. Un travail nécessite des ressources informatiques et ces ressources (CPU, mémoires, dispositifs d'entrée/sortie, etc.) sont disponibles en quantité limitée et doivent être

partagées entre les travaux en cours d'exécution.

Cette machine comprend un système d'exploitation SE qui assure entre autre la gestion des différentes ressources de la machine et permet l'accès simultané aux données communes (bases de données, fichiers,...) et à certains

programmes (utilitaires, bibliothèques,...).

La machine MAC comprend aussi au moins une mémoire MEM1 dans laquelle toute sorte de données peuvent être stockées. Des données peuvent être

des tables.

6 2812099

Le système informatique SYS comprend aussi au moins un agent AGM capable de déterminer pour chaque processus le taux de consommation des

ressources impliquées.

Le gros problème, tel qu'énoncé dans l'introduction, est qu'il n'existe pas de moyens de détection et de correction automatique de l'utilisation anormale de

ressources par un logiciel.

A cet effet, I'invention a pour objet un procédé d'autorégulation du taux de consommation de chaque ressource. Le procédé d'autorégulation comprend plusieurs étapes mis en oeuvre par l'agent AGM. De préférence, cet agent tourne o0 en boucle continue sur la machine MAC à surveiller. De préférence, cet agent est doté de sondes sur des ressources systèmes et est capable de déclencher des

actions lorsque des seuils sont atteints.

Les étapes sont les suivantes: Etape 1 A intervalle de temps, de préférence régulier, I'agent AGM détermine pour chaque processus actif dans le système le taux de consommation des ressources (par exemple du processeur CPU, de la mémoire ou des fichiers par disques) que demande un processus. Cet agent stocke ces informations dans une table dite de

ressources TRt incluse dans une mémoire du mémoire MEM1 du système.

Un telle table TRt donnant l'état des ressources à l'instant t peut être la suivante: Pid Nom %Cpu Mem Disque /tmp disque /users 3 srvl 12 1800k Ok 320k 7 procl 6 3400k 1200k 400k srv2 O 1200k 2300k 12000k 39 proc2 25 12400k 10k 400k Dans cette table,

7 2812099

la première colonne (Pid) désigne l'identificateur, c'est-à-dire le numéro qui identifie de façon unique un processus. Ce paramètre est utilisé, par exemple, dans les systèmes UNIX (Marque déposée); La deuxième colonne (Nom) correspond au nom du processus en question; La troisième colonne (% CPU) correspond au taux de consommation du processeur; La quatrième colonne (Mem2) correspond à la taille d'espace occupée de la mémoire; La cinquième colonne (Disque /tmp) correspond à la taille occupée par les fichiers temporaires sur le disque dur; La sixième colonne (Disque /users) correspond à la taille occupée par les

fichiers nommés /USER sur le disque dur.

L'agent AGM obtient les différentes valeurs de cette table de façon connue de l'homme du métier. Par exemple, les valeurs concernant les ressources CPU et mémoire sont obtenues dans la table système décrivant les processus. L'espace fichier est quant à lui obtenu en parcourant l'ensemble des fichiers ouverts par le processus en question, information contenue dans une table système. Dans ce dernier cas, seuls les fichiers réguliers ouverts en écriture sont retenus. Rappelons qu'un fichier régulier est un fichier qui se compose d'une liste

de blocs d'un disque.

Toutes les n secondes, I'agent AGM établit une table de ressources. On obtient alors, une 2ème table TRt2 à l'instant t=t2, une troisième TRt3 à l'instant t=t3, etc. Etape 2 On peut alors déduire des tables précédentes, à l'étape ET2, un état global des ressources sur un intervalle de temps (t - tl). Cet état global est mémorisé dans un tableau TGR, par exemple dans la mémoire MEM1. Un tel tableau peut être le suivant: Ressources ti t2... t %Cpu 80 55 12 Mém. Libre (octets) 18000k 24000K 60000k Espace /tmp libre (octets) 65000k 50000k 8000k Espace /users libre (octets) 32000k 28000k 22000K E tc. _ L'obtention de ce tableau peut être obtenu par tout autre moyen connu de

l'homme du métier.

De manière à simplifier grandement l'exposé de l'invention, on ne

s'intéressera dans la suite de la description qu'à une seule ressource

informatique, la mémoire libre MEM2.

Etape 3 Après avoir établit les table de ressources (TRt1,TRt2,TRt3, etc.) lors de la première étape ETI et déduit de ces tables, lors de la deuxième étape ET2, un

tableau TGR donnant l'état global des ressources sur un intervalle de temps (t -

tl), la solution consiste, lors d'une troisième étape ET3, à conserver, dans une mémoire quelconque du système, à l'instant t, pour chaque ressource, les

mesures sur l'intervalle de temps donné (t - tl).

La figure 2 est un graphe illustrant un exemple de réalisation des mesures effectuées (M1-M12) pour la ressource mémoire de tl à t = t12 (t12 est la dernière mesure effectuée). Cette figure représente un repère orthonormé comprenant un axe des abscisses et un axe des ordonnées. Dans notre exemple, I'axe des abscisses représente le temps et l'axe des ordonnées représente le taux de

consommation de la mémoire (de 0 à 100%).

Dans notre exemple, on a réalisé 12 mesures Mi (i = 1,...,12) réalisées à

des instants respectifs ti (i = 1,...,12) différents.

Etape4 L'agent AGM détermine ensuite, dans l'intervalle de temps (t12 -tl) , de préférence par interpolation linéaire, un certain nombre de droites selon que l'on tient compte des mesures sur un délai court Lc, moyen Lm ou long LI. Un exemple d'un programme de fonction d'interpolation est donné en annexe 1. On peut par

9 2812099

exemple utiliser la méthode mathématiques dite des moindres carrés, ajoutée d'un

mécanisme de lissage.

Naturellement, I'invention ne se limite pas uniquement à une méthode d'approximation du type interpolation linéaire. Tout autre méthode d'approximation d'interpolation non linéaire dont l'approximation fournie une droite la plus proche

des différents points de mesure peut être utilisée.

Dans notre exemple de réalisation, les mesures sont effectuées à intervalle régulier. On choisi, dans notre exemple, comme délai court Lc l'intervalle de temps (t12 - t10), comme délai moyen Lm l'intervalle de temps (t12 - t6) et comme délai long LI l'intervalle de temps (t12 - tl). Dans notre exemple de réalisation, le délai court Lc rassemble donc 3 mesures (M 10, Mll et M1 2), le délai moyen Lm rassemble 7 mesures (M6 M12) et le délai long 12 mesures

(Ml -M12).

Sur ces trois délais, on peut tracer, par exemple par interpolation linéaire,

trois droites linéaires Cc, Cm et Cl.

Etape 5 La solution consiste ensuite, à l'étape ET5, à déduire de ces droites différentes tendances: - la droite obtenue sur le délai court Lc est descendante, - la droite obtenue sur le délai moyen Lm est ascendante, - la droite obtenue sur la délai long LI est ascendante, Une droite descendante (pente négative) révèle que le taux de consommation de la mémoire diminue. A l'inverse, une droite ascendante (pente

positive) révèle que le taux de consommation de la mémoire augmente.

Etape 6 Lors d'une sixième étape (ET6), l'agent AGM se focalise de préférence sur les droites ascendantes. L'agent extrapole linéairement chacune des droites ascendantes de façon - à déduire l'évolution du taux de consommation de la mémoire, - à prédire et anticiper un éventuel blocage de la ressource mémoire

dans le déroulement du processus.

Le programme donné en annexe 1 est également utilisé pour le calcul de l'extrapolation. Comme indiqué précédemment, I'invention n'est pas limitée aux techniques d'extrapolation linéaire. Tout autre méthode d'approximation d'extrapolation non linéaire dont l'approximation fournie une droite la plus proche

des différents points de mesure peut être utilisée.

A noter que le sens d'exécution des étapes 5 et 6 est indifférent.

L'exécution de l'étape 6 avant l'étape 5 est tout à fait envisageable; La solution consisterait donc à extrapoler et à déterminer la pente de chacune des droites

obtenues par interpolation linéaire par la suite.

On peut voir sur le graphe de la figure 2 que l'extrapolation des droites Cl et Cm atteignent le taux de saturation de 100% aux points K1 et K2, respectivement. La projection orthogonale de ces points sur l'axe des abscisses

donnent deux points respectifs SI et Sm.

Selon une variante, il est possible, pour des raisons de sécurité, de fixer comme taux de saturation une valeur inférieur à 100%, par exemple à 97%. Ainsi, les points K1 et K2 seront les points d'intersection entre les droites linéaires Cl et Cm, respectivement, et la droite correspondant au taux de 97%. Dans la suite de

la description, on choisi comme taux de saturation 100%.

Etape 7 On peut alors déduire de l'extrapolation, en fonction des délais choisis (Lc, Lm, LI), I'intervalle de temps au bout duquel l'occupation de la mémoire risque

d'être à son maximum, à savoir 100%.

Pour le délai LI: La soustraction du temps SI au temps t12 (qui représente la dernière mesure) donne un intervalle de temps, que l'on notera A LI dans la suite de la

description, donnant le temps que mettra le taux de consommation pour passer de

sa valeur à l'instant t=t12 à sa valeur de saturation de 100%.

ll 2812099 Pour le délai Lm: La soustraction du temps Sm au temps t12 donne un intervalle de temps,

que l'on notera ALm dans la suite de la description, donnant le temps que mettra

le taux de consommation pour passer de sa valeur à l'instant t=t12 à sa valeur de

saturation de 100%.

Etape 8 L'agent détermine ensuite, lors d'une huitième étape (ET8), entre les intervalles de temps (A LI et A Lm) celui le plus critique, I'intervalle le plus critique étant bien évidemment l'intervalle le plus court des deux. Dans notre exemple, l'intervalle le plus court est A LI, donc le plus critique La solution consiste également à utiliser une table Tc incluant au moins une condition de seuil et au moins une action respective associée à la condition de seuil. Cette table est stockée en mémoire, par exemple dans la mémoire MEM1. Dans notre exemple, la table comprend deux conditions de seuil (CS1, CS2) et deux actions respectives (Action 1, Action 2). Dans cette table, si une

condition de seuil est vérifiée, I'action associée inscrite dans la table est exécutée.

Une telle table Tc peut être le suivante: Ressource Méthode Conditions de Action 1 Conditions de Action 2 seuil 1 (CS1) seuil 2 (CS2) Mémoire SYSTEM A Slim=10,Nli Notifier A Slim= 10,NI Tuer 5 m=1 l'Administrate im=3 processus ur non Etc._____________ critiques Etc. Dans cette table, la première colonne " Ressource " donne le nom de la

ressource susceptible d'être saturée, ici la mémoire.

De préférence, la deuxième colonne dite " Méthode " est le nom de la méthode qui donne la façon d'examiner la ressource en question. Cette méthode est une interface qui permet d'accéder aux informations associées à la ressource (par exemple créer une requête de type SQL pour interroger une table d'une base de données relationnelle, etc.). Cette table est extensible en ce sens que si on ajoute une ressource dans la première colonne et que la méthode associée n'est

12 2812099

pas définie dans l'agent, il suffit alors d'écrire la méthode et son nom dans la table.

Si la ressource est représentée par un objet, la méthode en question est une

interface qui permet d'accéder au contenu de cet objet (attributs,..).

La troisième colonne correspond à des conditions de seuil CS1 à vérifier et la quatrième colonne correspond à l'action (Action 1) à exécuter si cette condition de seuil CS1 est vérifiée. Dans notre exemple, deux paramètres sont fixés comme conditions de seuil CS1: A Slim, et Nlim. Le paramètre noté A Slim est un intervalle de temps fixé et représente un intervalle de temps critique en ce sens que si (A LI et/ou A Lm) est inférieur à cette condition de seuil, la ressource sera considérée comme en risque d'être saturée. Le paramètre Nlim est le nombre de dépassements successifs du seuil A Slim à partir duquel une action peut être lancée. La quatrième colonne correspond à des conditions de seuil CS2 à vérifier et la cinquième colonne correspond à l'action (Action 2) à exécuter si cette condition de seuil CS2 est vérifiée Cette table peut contenir un nombre indéterminé de conditions de seuil et

d'actions associées.

Etape 9 La solution consiste, pour l'agent AGM, à comparer la valeur d'intervalle

A LI à la valeur d'intervalle A Slim fixée au préalable dans la table Tc.

Avantageusement, la valeur de l'intervalle A Slim est paramétrable.

Si A LI est supérieur à A Slim (ET9A), aucune ressource n'est susceptible

d'être saturée, on revient donc à l'étape ET1 pour effectuer de nouvelles mesures.

Si A LI est inférieur à A Slim (ET9B), la ressource est susceptible d'être saturée, et une action peut être exécutée en fonction des valeurs fixées dans la table Tc. Sur la figure 2, on s'aperçoit que, dans notre exemple de réalisation, A LI

est inférieure à A Slim.

Etape 10 Lorsque A LI est inférieur à A Slim (ET9B), une autre étape ET10

consiste à calculer le paramètre Nlim.

13 2812099

Si le dépassement de l'intervalle A Slim apparaît pour la première fois, le paramètre Nlim vaut alors 1. A chaque dépassement successif de la valeur de

l'intervalle A Slim, la valeur du paramètre Nlim est incrémentée d'une unité.

Lorsque le dépassement de la valeur A Slim n'est plus vérifiée, la valeur du paramètre Nlim est automatiquement remise à 0. Etape 1 1 Préalablement au lancement de l'action, I'agent AGM identifie le ou les processus les plus gros consommateurs de cette ressource dans le délai io correspondant à l'intervalle le plus court Lc. Dans notre exemple de réalisation, on identifie proc2 comme le plus gros consommateur. Une exemple de table TGC donnant la consommation de certains processus peut être la suivante: Processus tO ti... Tt srvl (octects) 2400k 2500k 2600k procl (octets) 12000k 12000k 12000k srv2 (octets) 3200k 4200k 4300k proc2 (octets) 12000k 38000k 72000k

Cette table peut être stockée dans la mémoire MEM1.

De préférence, cette table est triée selon la quantité d'utilisation de la ressource (ici la mémoire) par ordre décroissant. Les N premiers processus

identifiés dans cette table seront identifiés comme les principaux consommateurs.

Le paramètre N (dans cette table, N=5) peut être directement configurable, ou bien déterminé par une valeur R configurable représentant la quantité minimale de la consommation de ressources au-dessus de laquelle un processus est retenu

comme grand consommateur.

A ce stade, le processus le plus consommateur (proc2) de la ressource

mémoire est détecté.

Ensuite, les étapes suivantes (ET12A, ET12B et ET12C) sont fonction de

la valeur du paramètre Nlim.

Etape 12A Si le paramètre Nlim ne vérifie pas les conditions de seuil fixées dans la table Tc (c'est-à-dire Nlim=l ou Nlim=3), I'étape ET1 est de nouveau exécutée pour effectuer de nouvelles mesures à un instant tj avec j=j+1. En l'espèce une nouvelle mesure est effectuée par l'agent AGM à l'instant t13 (j=12+1). Les étapes ET2-ET9 sont de nouveau exécutées. Dans notre exemple de réalisation, à l'étape ET3, on a choisi de conserver un même nombre de mesures pour tracer le graphe de la figure 2. Le tableau TGR donnant l'état global des ressources peut être déduit des tables TRt sur l'intervalle de temps (t1 3 - t2), et ainsi de suite pour

les nouvelles meures à effectuer.

Dans l'exemple de réalisation, supposons que le dépassement de l'intervalle A Slim apparaisse trois fois successivement: - Lors du premier dépassement, le paramètre Nlim vaut alors 1 (ET12B),

et Les conditions de seuil 1 définies dans la table Tc sont vérifiées.

- Lors du deuxième dépassement successif, le paramètre Nlim vaut alors 2 et aucune condition de seuil n'est vérifiée. l'étape ET1 est de nouveau exécutée pour effectuer de nouvelles mesures à un instant tj

avec j=j+1.

- Lors du troisième dépassement successif, le paramètre Nlim vaut alors 3 (ET12C), et Les conditions de seuil 1 définies dans la table Tc sont vérifiées. Les étapes 12B et 12C sont les suivantes: Etape 12B Lorsque Nlim=l, la table Tc indique qu'une action peut donc être exécutée. Dans notre exemple, I'action consiste à émettre une alarme à l'administrateur. Ce message indiquera à l'administrateur qu'il y a un risque de saturation de la mémoire; ce message indiquera également l'identificateur (Pid)

du processus le plus gros consommateur de la ressource mémoire et son nom.

Un exemple de message peut être le suivant:

RISQUE DE SATURATION MEMOIRE

Pid:29 Nom: proc2

2812099

Un tel message peut être visible sur l'écran d'un ordinateur.

Après avoir émis une notification à l'administrateur, la solution consiste: - à donner ou non la possibilité à l'administrateur de tuer tout ou partie des processus consommateurs définis dans la table TGC, - et à revenir ensuite à l'étape ET1 pour effectuer de nouvelles mesures à l'instant tj=t(j+1). En l'espèce une nouvelle mesure est effectuée à

l'instant t1 3. Les étapes ET2-ET9 sont de nouveau exécutées.

Nous avons supposé précédemment que, dans l'exemple de réalisation, le dépassement de l'intervalle A Slim apparaît trois fois successivement. La valeur du paramètre Nlim atteint alors la valeur de 3 (Nlim=3). Cette condition de seuil

(CS2) apparaît dans la table Tc.

Etape 12C Si Nlim est égal à 3, à la lecture de la table Tc, I'action correctrice associée à la deuxième condition de seuil consiste à tuer (ou détruire) un certain nombre de processus. A cet effet, la solution consiste par exemple à distinguer des processus critiques de processus non critiques. Un processus non critique peut être défini comme un processus utilisant une ressource susceptible d'être saturée, en l'espèce la mémoire, et dont la suppression (ou la suspension) n'a pas d'impact sur l'accomplissement d'un travail important (non prioritaire). A l'inverse, un processus critique (par exemple un programme système) peut être défini comme un processus essentiel à l'accomplissement d'un travail important (prioritaire). Dans notre exemple de réalisation, I'action consiste à tuer cinq processus

non critiques.

Etape 12C1 A l'étape 12C1, la solution consiste alors à établir, avantexécution de cette action, une liste de processus consommateurs de ressources les moins

1]6 2812099

critiques. Une table TNC spécifique décrit un exemple incluant 5 processus non critiques associés au programme. Cette table peut avoir la forme suivante: Utilisateur Groupe processus util2 groupe2 proc2 util 3 groupe4 groupe5 proc5 De préférence, cette table est stockée en mémoire, par exemple dans la

mémoire MEM1.

Dans notre exemple, sont considérés comme non critiques, - Le processus proc2 lancé par l'utilisateur util2, - Tous les processus lancés par l'utilisateur util3, - Tous les processus lancés par tous les utilisateurs du groupe4,

- Le processus proc5 lancé par n'importe quel utilisateur du groupe5.

Etape 12C2 Après l'identification des 5 processus non critiques, la solution consiste à

tuer tout ou partie de ces 5 processus lors d'une étape ET12C2.

Etape 12C3 Enfin, après avoir tués tout ou partie des 5 processus, le taux de consommation de la mémoire diminue en conséquence et le procédé se poursuit, et l'étape ET1 est à nouveau exécutée pour une nouvelle mesure. Les étapes

(ET2, etc.) suivantes sont de nouveau réalisées.

Les différentes tables (TRt, TGR, TCS, Tc, TNC) peuvent être visible sur un écran d'ordinateur. Cependant, avantageusement, le procédé de l'invention est

dynamique et transparent pour l'utilisateur.

D'une manière générale, on peut dire que l'invention a pour objet un procédé d'autorégulation, dans un système informatique (SYS), de la consommation d'au moins une ressource physique (MEM2) et/ou logicielles par au moins un processus (srvl, procl, srv2, proc2), ledit système comprenant au moins un agent AGM doté de moyens de mesure de la consommation d'au moins une ressource en fonction du temps, caractérisé en ce qu'il consiste, pour l'agent AGM, - à prédire, par l'intermédiaire d'une méthode d'approximation, I'évolution de la consommation de tout ou partie des ressources (MEM2) en fonction de mesures effectuées, - à identifier le (ou les) processus le(s) plus gros consommateur(s) de ressources, - et à lancer, éventuellement, une action en fonction d'au moins une

condition de seuil (CS1, CS2) associée et préalablement définie.

On a vu dans notre exemple que la prédiction de l'évolution de la consommation d'une ressource consiste à réaliser des mesures sur au moins un délai (Lc, Lm, LI) d'un intervalle de temps donné (t-t1), et à déterminer pour chaque délai, par l'intermédiaire d'une méthode d'approximation propre à fournir une droite la plus proche des différents points de mesure, la tendance respective

(croissance, décroissance, ou stabilité) de la consommation de la ressource.

Dans notre exemple de réalisation, on a choisi méthode d'approximation est une méthode dite d'interpolation linéaire (aussi appelée méthode des moindres carrés). La prédiction de la consommation consiste, de préférence, à extrapoler la tendance de la consommation et à déterminer l'intervalle de temps (A LI, A Lm) au bout duquel il est probable que la ressource en question atteigne un état de saturation. L'invention consiste à autoréguler la consommation des ressources de manière à éviter des blocages. Dans notre exemple de réalisation, on a vu que la solution peut consister, pour chaque ressource, à fixer au préalable comme condition de seuil au moins un intervalle (A Slim) paramétrable représentant l'intervalle de temps critique que ne doit pas dépasser (A LI et/ou A Lm), en ce que si (A LI et/ou A Lm) est inférieure à cette condition de seuil, la ressource sera considérée comme en risque d'être saturée. Ensuite, une action peut être

exécutée de façon à réduire le taux de consommation de cette ressource.

18 2812099

La solution propose également d'introduire un autre paramètre Nlim comme condition de seuil. Dans notre exemple de réalisation, ce paramètre (Nlim) représente le nombre maximum de dépassements successifs du seuil fixé A Slim au dessus duquel une action est exécutée, et ne ce que, si les conditions de seuil (Nlim et A Slim) sont vérifiées, I'agent exécute une action.

Naturellement, l'invention ne se limite pas à ces deux conditions de seuil.

D'autres paramètres autres que (Nlim et A Slim) peuvent être utilisés.

On a vu dans l'exemple de réalisation qu'une action est lancée si et seulement si les conditions de seuil sont atteintes. A cet effet, préalablement à I l'exécution d'une action correctrice, la solution consiste, pour l'agent AGM, à vérifier si une condition de seuil est atteinte, et dans l'affirmative, à émettre une action d'information consistant en une notification d'alarme à un administrateur du système. Dans notre exemple de réalisation, on a choisi de distinguer, parmi les processus les processus les plus consommateurs d'une ressource, les processus dits critiques des processus dits non critiques. Un processus non critique est un processus utilisant une ressource susceptible d'être saturée, et dont la suppression (ou la suspension) n'a pas d'impact sur l'accomplissement d'un travail. Un processus critique est un processus essentiel à l'accomplissement d'un travail. Cette distinction étant réalisée, préalablement à l'exécution d'une action correctrice, la solution consiste à vérifier, pour l'agent AGM, si une condition de seuil est atteinte, et dans l'affirmative, à déterminer au moins un processus non critique, et consiste ensuite, à l'exécution de l'action, à tuer ledit au moins un

processus non critique.

Par ailleurs, dans notre exemple de réalisation, lorsqu'une condition de seuil est vérifiée, la solution consiste à identifier tout ou partie des processus les plus consommateurs, et la notification d'alarme consiste à fournir à l'utilisateur au moins l'identificateur du processus le plus consommateur de la ressource en question. Dans notre exemple, cette alarme d'information peut être affichée sur un écran d'ordinateur, cette alarme comprenant au moins l'identificateur du processus le plus consommateur. L'utilisateur, suite à la réception de la notification d'alarme fournissant à l'utilisateur au moins l'identificateur du processus le plus consommateur, peut alors, s'il le souhaite, tuer tout ou partie

des ressources les plus consommateurs.

Selon une autre variante, lorsqu'une condition de seuil est vérifiée, à identifier tout ou partie des processus les plus consommateurs, et si le nombre de processus non critique est supérieur à l'unité, I'administrateur sélectionne celui ou ceux qu'il souhaite tuer. Avantageusement, la solution consiste à afficher sur un écran d'ordinateur, par l'intermédiaire d'une interface graphique tout ou partie des processus non critiques, et à sélectionner le processus non critique sur le fenêtre

pour le tuer (ou détruire).

La tendance d'une droite doit être déterminée. Dans notre exemple, on a vu que la solution peut consister à tracer pour chaque délai (Lc, Lm, LI) et par interpolation linéaire au moins une droite respective (Cc, Cm, Cl), et en ce que la pente de ladite au moins une droite donne la tendance respective (croissance, décroissance, ou constante) de la consommation de la ressource. Dans notre exemple de réalisation, la solution consiste avantageusement à établir une table des actions Tc incluant - le nom de la ressource, - la façon d'examiner cette ressource - au moins une condition de seuil et l'action respective à lancer, et en ce que l'agent AGM consulte cette table de façon à connaître l'action

associée à la condition de seuil vérifiée.

On a vu aussi dans notre exemple de réalisation que les processus les plus consommateurs peuvent être visibles sur une table TGC. La création de cette table consiste à trier les processus selon la quantité d'utilisation de la ressource en question par ordre décroissant, à identifier les N premiers processus de cette table comme les principaux consommateurs de la ressource, et en ce que le paramètre N est configurable ou déterminé par une valeur R configurable représentant la quantité minimale de la consommation de la ressources au dessus de laquelle un

processus est retenu comme grand consommateur.

Il en résulte un agent AGM pour l'autorégulation de la consommation d'au moins une ressource physique (MEM2) et/ou logicielles par au moins un processus (srvl, procl, srv2, proc2), ledit agent étant doté de moyens de mesure de la consommation d'au moins une ressource en fonction du temps, caractérisé en ce qu'il comprend - des moyens de prédiction de l'évolution de la consommation de tout ou partie des ressources (MEM2) en fonction de mesures effectuées, - et des moyens de lancement d'au moins une action (Action1, Action2) en fonction d'au moins une condition de seuil (CS1, CS2) associée et préalablement définie dans une mémoire informatique,

pour la mise en oeuvre du procédé tel que défini précédemment.

La solution a également pour objet le système informatique (SYS) mettant en oeuvre le procédé défini précédemment. Ce système comprend au moins une ressource physique (MEM2) et/ou logicielle, au moins un processeur, au moins un processus (srvl, procl, srv2, proc2) utilisant ladite au moins une ressource pour mener à bien son exécution, au moins un agent AGM doté de moyens de mesure de la consommation d'au moins ladite ressource en fonction du temps, et est caractérisé en ce que l'agent comprend des moyens - des moyens de prédiction de l'évolution de la consommation de tout ou partie des ressources (MEM2) en fonction de mesures effectuées, et des moyens de lancement d'au moins une action (Action1, Action2) en fonction d'au moins une condition de seuil (CS1, CS2) associée et

préalablement définie dans une mémoire informatique.

Il ressort de la présente description que la solution offre de nombreux

avantages.

La solution donne la possibilité de prédire des risques de blocage au cours de l'exécution d'un programme et de lancer des actions correctrices automatiquement de façon à ce que le programme en question poursuive son

exécution sans problème.

Le gros avantage est que la détection d'une consommation excessive et le lacement de l'action associée s'effectue dynamiquement en toute transparence

pour l'administrateur.

21 2812099

La présente solution offre également un très grande souplesse dans le paramétrage des conditions de seuil en ce sens que l'administrateur peut saisir lui même les valeurs des conditions de seuil. Il fixe lui-même la valeur des

paramètres Nlim et de l'intervalle A Slim.

ANNEXE 1

/* Tables des valeurs de l'interpolation */ /* nombre de points */ extern int nbpts; /* table des x */ extern int tx[]; /* table des y */ extern int ty[]; /* Fonction: interpolation * Calcul les parametres de la droite la * plus proche des points donnes dans les tables tx et ty * * parametres de retour: a,b tels que y = ax + b */ void interpolation( double *a, double *b) { double sigmes = 0.0; double sigtim = 0.0; double sigmescar = 0.0; double sigtimcar = 0.0; double sigxy = 0.0; double averagemes; double averagetim; int i; for (i = 0; i < nbpts; i++) { int t; double value; t = tx[i] - tx[O]; value = ty[i] - ty[0]; sigmes += value; sigtim += t; 23 i2812099 sigmescar += value * value; sigtimcar += t * t; sigxy += value * t; }averagemes = (nbpts) ? sigmes / nbpts: 0; averagetimes = (nbpts) ? sigtimes / nbpts: 0; averagetimr = (nbpts) ? sigtiin / nbpts:0; { double divl, div2; divl = averagetim - 2 * sigtim; div2 = (divl) ? sigtimcar + averagetim / divl

: 0.0;

*a = (div2) ? (sigxy - (averagetim * sigmes)) / div2: 0.0; *a = (nbpts) ? *a * (4.0 - 6.0 / (((double) nbpts + 1.0) * (1.0 - 1.0 / (1.0 + (double) nbpts

/2.0 -

(double) nbpts * (double) nbpts *

3.0 / 2.0 +

(double) nbpts * (double) nbpts * (double) nbpts)))): 0.0; } *b = 0.0; for (i = 0; i < nbpts; i++) { int t; double value; t = tx[i] - tx[0]; value = ty[i] - ty[0]; *b += value - *a * t; } *b = (nbpts) ? *b / nbpts: 0; *b += ty[O] - *a * tx[0]; } int tx[50]; int ty[50]; int nbpts; /* Programme de test de la fonction d'interpolation * genere des tables de points proches de droites, * calcule la droite d'interpolation, et affiche sur un * diagramme les points generes aleatoirement, ainsi * que les points de la droite generee. */ main() { double a, b; int k; srand(time(0)); for (k=0;k<10;k++) { int i; int j; char prl[600][600]; int depl; int init = 50 - rand() % 25; while ((depl = (6 - rand() % 12)) < 2 && depl

> -2);

nbpts = 50; for (i = 0; i < nbpts; i++) { int shift = rand() % depl; if (depl < O) shift = -shift; tx[i] = i; ty[i] = ((i) ? ty[i- 1]: init) + shift; } interpolation(&a, &b); printf("Equation de la droite obtenue: y = %fx + %f\n", a, b); for (i = 0; i < 120; i++) { for (j = O; j < 120; j++ ) prl[i][j] = ' '; prl[i][120 - 1] = '\0'; } for (i = 0; i < nbpts; i++) { double esty = a * (double) i + b; int iesty = esty; prl[60 - ty[i]][i * 4] = '*'; prl[60 - iesty][i * 4] = '+'; printf("point * en %d,%d,point + en %d,%d\n", i,ty[i], i, iesty); } for (j = 0; j < 60; j++) { if (! (j % 10)) printf("%2d 1",60 - j); else printf(" 1"); printf("%s\n", prl[j]); } printf(" L_ _

_ _I_ _ I_ ____I_

I_ _ I __ _ _ _ l\n'); printf(" 0 10

20 30 40

60\n"); }

Claims (15)

REVENDICATIONS

1- Procédé d'autorégulation, dans un système informatique (SYS), de la consommation d'au moins une ressource physique (MEM2) et/ou logicielles par au moins un processus (srvl, procl, srv2, proc2), ledit système comprenant au moins un agent AGM doté de moyens de mesure de la consommation d'au moins une ressource en fonction du temps, caractérisé en ce qu'il consiste pour l'agent AGM, - à prédire, par l'intermédiaire d'une méthode d'approximation, I'évolution de la consommation de tout ou partie des ressources (MEM2) en fonction de mesures effectuées, - à identifier le (ou les) processus le(s) plus gros consommateur(s) de ressources, - et à lancer, éventuellement, une action (Action1, Action2) en fonction

d'au moins une condition de seuil (CS1, CS2) associée et préalablement définie.

2- Procédé selon la revendication 1, caractérisé en ce que la prédiction de l'évolution de la consommation d'une ressource consiste à réaliser des mesures sur au moins un délai (Lc, Lm, LI) d'un intervalle de temps donné (t-t1), et à déterminer pour chaque délai, par l'intermédiaire d'une méthode d'approximation propre à fournir une droite la plus proche des différents points de mesure, la tendance respective (croissance, décroissance, ou stabilité) de la consommation

de la ressource.

3- Procédé selon la revendication 1 ou 2, caractérisé en ce que la

méthode d'approximation est une méthode dite d'interpolation linéaire.

4- Procédé selon l'une des revendications 1 à 3, caractérisé en ce que la

prédiction de la consommation consiste à extrapoler la tendance de la consommation et à déterminer l'intervalle de temps ( A LI, A Lm) au bout duquel il

est probable que la ressource en question atteigne un état de saturation.

- Procédé selon l'une des revendications 1 à 4, caractérisé en ce qu'il

consiste, pour chaque ressource, à fixer au préalable comme condition de seuil au moins un intervalle (A Slim) paramétrable représentant un intervalle de temps critique en ce sens que si (A LI et/ou A Lm) est inférieur à cette condition de seuil, la ressource sera considérée comme en risque d'être saturée et une action peut

être exécutée de façon à réduire le taux de consommation de cette ressource.

6- Procédé selon l'une des revendications 1 à 5, caractérisé en ce qu'il

consiste, à fixer comme condition de seuil un paramètre (Nlim) représentant le nombre maximum de dépassements successifs du seuil fixé A Slim au dessus duquel une action est exécutée, et en ce que, si les conditions de seuil (Nlim et

A Slim) sont vérifiées, I'agent exécute une action.

7- Procédé selon l'une des revendications 1 à 6, caractérisé en ce qu'il

consiste, pour l'agent AGM, préalablement à l'exécution d'une action correctrice, à vérifier si une condition de seuil est atteinte, et dans l'affirmative, à émettre une action d'information consistant en une notification d'alarme à un administrateur du système.

8- Procédé selon l'une des revendications 1 à 6, caractérisé en ce qu'il

consiste, pour l'agent AGM, à distinguer, parmi les processus les processus les plus consommateurs d'une ressource, les processus dits critiques des processus dits non critiques, un processus non critique étant un processus utilisant une ressource susceptible d'être saturée, et dont la suppression (ou la suspension) n'a pas d'impact sur l'accomplissement d'un travail, un processus critique étant un processus essentiel à l'accomplissement d'un travail, en ce qu'il consiste, préalablement à l'exécution d'une action correctrice, à vérifier si une condition de seuil est atteinte, et dans l'affirmative, à déterminer au moins un processus non critique, et en ce qu'il consiste, à l'exécution de l'action, à tuer (ou détruire) ledit au

moins un processus non critique.

9- Procédé selon la revendication 7, caractérisé en que, lorsqu'une condition de seuil est vérifiée, à identifier tout ou partie des processus les plus consommateurs, et en ce que la notification d'alarme consiste à fournir à l'utilisateur au moins l'identificateur du processus le plus consommateur de la

ressource en question.

- procédé selon la revendication 8, caractérisé en ce que, lorsqu'une condition de seuil est vérifiée, à identifier tout ou partie des processus les plus consommateurs, et en ce que, si le nombre de processus non critique est

supérieur à l'unité, I'administrateur sélectionne celui ou ceux qu'il souhaite tuer.

11- Procédé selon la revendication 10, caractérisé en qu'il consiste à 0o afficher sur un écran d'ordinateur, par l'intermédiaire d'une interface graphique tout ou partie des processus non critiques, et en ce qu'il consiste à sélectionner le

processus non critique sur le fenêtre pour le tuer.

12- Procédé selon la revendication 2 ou 3, caractérisé en qu'il consiste à tracer pour chaque délai (Lc, Lm, LI) et par interpolation linéaire au moins une droite respective (Cc, Cm, Cl), et en ce que la pente de ladite au moins une droite donne la tendance respective (croissance, décroissance, ou constante) de la

consommation de la ressource.

13- Procédé selon l'une des revendications 1 à 12, caractérisé en ce qu'il

consiste à établir une table des actions Tc incluant - le nom de la ressource, - la façon d'examiner cette ressource

- au moins une condition de seuil et l'action respective à lancer.

et en ce que l'agent AGM consulte cette table de façon à connaître l'action

associée à la condition de seuil vérifiée.

14- Procédé selon la revendication 7, caractérisé en qu'il consiste à afficher l'alarme d'information sur un écran d'ordinateur, cette alarme comprenant

au moins l'identificateur du processus le plus consommateur.

- Procédé selon l'une des revendications 8 à 10, caractérisé en ce qu'il

consiste à afficher sur une table les processus les plus consommateurs, à trier ensuite ces processus selon la quantité d'utilisation de la ressource en question par ordre décroissant, à identifier les N premiers processus de cette table comme les principaux consommateurs de la ressource, et en ce que le paramètre N est configurable ou déterminé par une valeur R configurable représentant la quantité minimale de la consommation de la ressource au dessus de laquelle un processus

est retenu comme grand consommateur.

16- Procédé selon la revendication 9, caractérisé en ce qu'il consiste, pour l'utilisateur, suite à la réception de la notification d'alarme fournissant à l'utilisateur 1o au moins l'identificateur du processus le plus consommateur, à tuer tout ou partie

des ressources les plus consommateurs.

17- Agent AGM pour l'autorégulation de la consommation d'au moins une ressource physique (MEM2) et/ou logicielles par au moins un processus (srvl, procl, srv2, proc2), ledit agent étant doté de moyens de mesure de la consommation d'au moins une ressource en fonction du temps, caractérisé en ce qu'il comprend - des moyens de prédiction de l'évolution de la consommation de tout ou partie des ressources (MEM2) en fonction de mesures effectuées, - et des moyens de lancement d'au moins une action (Action1, Action2) en fonction d'au moins une condition de seuil (CS1, CS2) associée et préalablement définie dans une mémoire informatique,

pour la mise en oeuvre du procédé tel que défini par l'une des revendications

précédentes. 18- Système informatique (SYS) pour la mise en oeuvre du procédé selon

l'une quelconque des revendications 1 à 16, comprenant au moins une machine

comprenant au moins une ressource physique (MEM2) et/ou logicielle, au moins un processeur, au moins un processus (srvl, procl, srv2, proc2) utilisant ladite au moins une ressource pour mener à bien son exécution, ledit système comprenant au moins un agent AGM doté de moyens de mesure de la consommation d'au moins ladite ressource en fonction du temps, caractérisé en ce que l'agent

comprend des moyens définis par la revendication 17.

19- Système selon la revendication 18, caractérisé en ce qu'il comprend des moyens de stockage informatique pour mémoriser dans une table Tc au

moins une condition de seuil et l'action associée, cette table incluant en outre au moins le nom de la ressource concernée, et la méthode permettant d'analyser5 cette ressource.