LES CAHIERS d'AIX
Publication réservée aux abonnés du Point Service AIX
Janvier 1998

LoadLeveler - Répartition de charge machine

Jean-Luc ALBIN

Introduction

Loadleveler est un produit de répartition de charge batch sur une machine ou un ensemble de machines. Cet ensemble de machines est appelé : "Cluster Loadleveler.".

LoadLeveler doit être installé sur toutes les machines du cluster. De même, un utilisateur "loadl" doit être créé sur l'ensemble des machines du cluster avec le même UID, GID et les permissions RSH entre toutes les machines, pour permettre l'administration du cluster.

Caractéristiques principales

Central Manager

Une machine, à l'intérieur du cluster, joue le rôle de Central Manager, ceci signifie que la soumission des travaux batch, faite depuis l'une quelconque des machines du cluster, est traitée par le Central Manager ; celui-ci identifie la machine d'exécution et établit la communication entre la machine de soumission et la machine d'exécution.

Classe

Pour mettre en oeuvre une architecture de répartition de travaux entre machines, la notion de base utilisée est la Classe.
L'administrateur du cluster devra établir les critères :

d'ouverture et de fermeture de classes,
de nombre de jobs s'exécutant simultanément sur la même machine,
de nombre de jobs par classe,
de nombre de classes par machine,
de valeurs limites d'un job pris sur la CPU,
de taille des fichiers,
etc.

Configuration

Le produit dispose de deux fichiers de configuration pour mettre en oeuvre une architecture d'exécution de travaux. Ce sont :

LoadL_admin
LoadL_config.
Celui-ci sera remplacé par le fichier LoadL_config.local si ce dernier est renseigné. En effet, le fichier "LoadL_config.local" est propre à la machine et prend le pas sur celui du cluster.

Le fichier LoadL_admin

Il décrit le cluster sous forme de trois ressources physiques :

Les machines du cluster et le rôle qu'elles y jouent (central manager, machine de soumission seulement, machine d'exécution).
Les classes du cluster ; par exemple : les limites de la classe (temps CPU, taille mémoire, ...), les utilisateurs autorisés ou non dans la classe, la priorité de la classe, etc.
Les utilisateurs du cluster, leur classe par défaut, le nombre maximum de jobs qu'ils peuvent soumettre, etc.

Le fichier LoadL_config

Indique les administrateurs du cluster, mais surtout les critères d'ouverture de classes, de suspension, de redémarrage...
On y précise également le nombre de jobs actifs simultanément.

Interactivité

Un des avantages du produit est sa capacité à prendre en compte l'interactivité dans la gestion des batches.
Ainsi, un job batch en cours d'exécution peut être suspendu si la charge interactive s'accroît (le job pourra, à terme, résider en totalité dans l'espace de pagination), et l'exécution du batch pourra reprendre si la charge interactive diminue. De cette façon, on peut favoriser le travail interactif par rapport au batch.

Accounting

Le produit dispose de la facilité d'accounting à partir d'une large collecte d'informations.

Exemple réel

Fichier LoadL_config.local

Voici un cas réel de configuration du fichier "LoadL_config.local" :

+--------------------------------------------------------------------------------+
|                                                                                |
|                                                                                |
| Class        = {"No_Class" "A" "B" "C" "D" "E" "F" "Wend"}                     |
| MAX_STARTERS = 8                                                               |
| HighLoad1    = 1.5                                                             |
| HighLoad2    = 2.0                                                             |
| HighLoad3    = 3.0                                                             |
| BackgroundLoad = 0.6                                                           |
| #                                                                              |
| # Definition des parametres NUIT et WEND                                       |
| #                                                                              |
| NUIT = (( tm_wday >0) && (tm_wday <6) && (tm_hour<9) && (tm_hour>18)) |
| #                                                                              |
| WEND = (tm_wday == 6) || (tm_wday == 0) || \                                   |
|        (( tm_wday == 5) && (tm_hour > 18)) || \                             |
|        (( tm_wday == 1) && (tm_hour < 9))                                   |
| #                                                                              |
| JOUR = (( tm_wday >0) && (tm_wday <6) && (tm_hour>=9) && (tm_hour<=18)|
| #                                                                              |
| START : (Class == "No_Class") || \                                             |
|         (Class == "A") || \                                                    |
|         (Class == "B") || \                                                    |
|         (Class == "C") || \                                                    |
|         ((Class == "D") && $(NUIT)) || \                                       |
|         ((Class == "E") && $(NUIT)) || \                                       |
|         ((Class == "F") && $(NUIT)) || \                                       |
|         ((Class == "Wend") && $(WEND)) || \                                    |
| #                                                                              |
| SUSPEND : (( Class == "D") && $(JOUR) && (LoadAvg >= $(HighLoad3))) ||      |
|           (( Class == "E") && $(JOUR) && (LoadAvg >= $(HighLoad3))) ||      |
|           (( Class == "F") && $(JOUR) && (LoadAvg >= $(HighLoad3))) ||      |
|           (( Class == "Wend") && $(JOUR) && (LoadAvg >= $(HighLoad2)))      |
| #                                                                              |
| CONTINUE :(( Class == "D") && (LoadAvg <= $(BackgroundLoad))) || \          |
|           (( Class == "E") && (LoadAvg <= $(BackgroundLoad))) || \          |
|           (( Class == "F") && (LoadAvg <= $(BackgroundLoad))) || \          |
|           (( Class == "Wend") && (LoadAvg <= $(HighLoad1))) || \            |
|                                                                                |
|                                                                                |
+--------------------------------------------------------------------------------+

Le fichier précédant montre que :

Jusqu'à 8 jobs peuvent s'exécuter simultanément sur la machine.
Il n'y a pas plus d'un job par classe.
Quatre seuils de charge sont définis.
Les paramètres JOUR, NUIT, WEND sont definis.
Les classes A, B, C et No_class sont démarrées.
Les classes D, E et F sont démarrées la nuit grÔce à la variable $(NUIT).
La classe Wend est démarrée le week-end.
Les classes D, E et F seront suspendues durant la journée si la charge de la machine dépasse le seuil HighLoad3 (défini ici à la valeur 3.0).
La classe Wend sera suspendue durant la journée si la charge machine dépasse le seuil HighLoad2 (défini ici à la valeur 2.0).
Les classes D, E, F et Wend seront réouvertes si la charge de la machine baisse.

Fichier LoadL_admin

Dans notre exemple réel, le fichier LoadL_admin est le suivant :

+--------------------------------------------------------------------------------+
|                                                                                |
|                                                                                |
| default:   type = machine                                                      |
| #          central_manager = false  # default not central manager              |
| #          schedd_host = false      # default not a public scheduler           |
| #          submit_only = false      # default not a submit-only machine        |
| #          speed = 1                # default machine speed                    |
| #          cpu_speed_scale = false  # scale cpu limits by speed                |
|                                                                                |
|                                                                                |
| default:   type = class             # default class stanza                     |
| #          priority = 0             # default ClassSysprio                     |
| #          max_processors = -1      # default max processors (no limit)        |
|                                                                                |
|                                                                                |
| default:   type = user              # default user stanza                      |
| #          priority = 0             # default UserSysprio                      |
|            default_class = No_Class # default class, not an option             |
|            default_group = No_Group # default group, not an option             |
| #          maxjobs = -1             # default maximum jobs user allowed        |
| #                                   # to run simult. (no limit)                |
| #          maxqueued = -1           # default maximum jobs user allowed        |
| #                                   # to run simult. (no limit)                |
| default:   type = group             # default group stanza                     |
| #          priority = 0             # default GroupSysprio                     |
| #          maxjobs = -1             # default maximum jobs group is            |
| #                                   # allowed to run simult. (no limit)        |
| #          maxqueued = -1           # default maximum jobs group is            |
| #                                   # allowed on system queue (no limit)       |
| ########################################################################       |
| ########################################################################       |
| rsf_test   type = machine          central_manager = true                      |
| #                                                                              |
|                                                                                |
|                                                                                |
+--------------------------------------------------------------------------------+

On peut remarquer qu'ici la machine "rsf_test" est central manager du cluster, où les classes et les utilisateurs ont des valeurs prédéfinies.

Conclusion

Il n'est pas question, ici, de faire une présentation exhaustive du produit LoadLeveler...
Mais il est cependant important de noter que ce produit est disponible, bien sűr, pour la plate-forme AIX, mais également sur les plates-formes SUN(TM), HP(TM) et SGI(TM).
On peut avoir, dans un même réseau de machines, des plates-formes matérielles différentes; il faut simplement s'assurer que le niveau du LoadLeveler est le même sur toutes les machines.

Noter enfin que le produit LoadLeveler constitue le module de répartition de travaux de l'offre
IBM Tivoli TME10. .

[ Top of Page | Previous Page | Next Page | Table of Contents ]

LES CAHIERS d'AIX Publication réservée aux abonnés du Point Service AIX Janvier 1998

LES CAHIERS d'AIX
Publication réservée aux abonnés du Point Service AIX
Janvier 1998