Le travail par lots
Ce mode de fonctionnement devient essentiel dans les années 1950, lorsque les ordinateurs sont rares, coûteux et doivent être utilisés le plus efficacement possible. Il restera ensuite très important pour les traitements répétitifs et massifs : paie, facturation, mises à jour de fichiers ou calculs scientifiques.
Pourquoi le traitement par lots apparaît
Sur les premiers ordinateurs, une grande partie du temps peut être perdue entre deux programmes : chargement des cartes perforées, préparation des périphériques, récupération des résultats ou intervention de l’opérateur.
Le traitement par lots consiste à préparer une file de travaux, appelés jobs. Une fois le traitement lancé, la machine exécute successivement ces travaux avec le moins d’interruptions possible.
L’objectif est donc simple : réduire les temps morts et rentabiliser au maximum une machine très coûteuse.
Comment fonctionne un traitement par lots ?
Dans les années 1950 et 1960, les programmes et leurs données sont souvent enregistrés sur des cartes perforées ou des bandes magnétiques.
Le programmeur prépare son travail puis le confie au centre de calcul. Celui-ci est ajouté à une file d’attente et exécuté lorsque son tour arrive. Les résultats sont ensuite imprimés ou enregistrés sur un support afin d’être récupérés plus tard.
Il n’y a donc pratiquement aucun dialogue avec la machine pendant l’exécution. Si le programme contient une erreur, il faut la corriger puis soumettre à nouveau le travail.
Le cycle peut ainsi être assez long :
préparer → soumettre → attendre → récupérer le résultat → corriger → recommencer.
L’IBM 704 : un exemple des années 1950
L’IBM 704, introduit au milieu des années 1950, illustre bien cette évolution.
Les programmeurs remettent leurs paquets de cartes au centre de calcul. Plusieurs travaux peuvent alors être regroupés et exécutés successivement, tandis que les résultats sont produits sur imprimante ou bande magnétique.
C’est également autour de l’IBM 704 que sont développés certains des premiers systèmes capables d’enchaîner automatiquement plusieurs travaux. Ces logiciels constituent une étape importante vers les futurs systèmes d’exploitation.
Les moniteurs : automatiser l’enchaînement des programmes
Au départ, l’opérateur doit intervenir fréquemment entre deux programmes. Pour réduire ces manipulations, apparaissent des programmes appelés moniteurs.
Un moniteur reste présent dans la machine et prend automatiquement en charge une partie du travail :
- charger le programme suivant ;
- lancer son exécution ;
- récupérer le contrôle lorsqu’il se termine ;
- passer au travail suivant.
Ces logiciels préfigurent les systèmes d’exploitation, qui prendront progressivement en charge l’exécution des programmes, les périphériques et l’utilisation des ressources de la machine.
Le spooling : ne plus attendre les périphériques
Un autre problème apparaît rapidement : les lecteurs de cartes et les imprimantes sont beaucoup plus lents que le processeur.
Le spooling permet de transférer à l’avance les travaux vers un support rapide, généralement un disque, puis d’y conserver également les résultats avant leur impression.
Le processeur n’a donc plus besoin d’attendre directement le lecteur de cartes ou l’imprimante. Les calculs et les entrées-sorties peuvent être organisés beaucoup plus efficacement.
JCL : expliquer au système ce qu’il doit faire
Avec des systèmes de plus en plus complexes, il devient nécessaire de décrire précisément le travail à exécuter : programme à lancer, fichiers utilisés, périphériques nécessaires ou succession des différentes étapes.
IBM développe notamment le JCL (Job Control Language) pour ses systèmes OS/360 et leurs descendants.
Le programmeur peut ainsi indiquer au système, avant l’exécution, comment son travail doit être organisé.
Du batch au time-sharing
Le principal défaut du traitement par lots est son absence d’interactivité. Le programmeur peut attendre longtemps avant de découvrir une simple erreur.
Dans les années 1960, le time-sharing propose une autre approche : plusieurs utilisateurs travaillent directement depuis des terminaux et partagent le temps du processeur.
Le time-sharing ne fait pourtant pas disparaître le batch. Les deux modèles coexistent : l’interactivité est adaptée au développement et au dialogue avec la machine, tandis que le traitement par lots reste efficace pour les travaux longs, répétitifs ou programmés à l’avance.
Pourquoi le traitement par lots est important
Le traitement par lots constitue une étape essentielle dans l’évolution de l’informatique. Il oblige les centres de calcul à organiser les travaux, automatiser leur enchaînement et mieux gérer les ressources des machines.
Il contribue ainsi directement à l’apparition des premiers systèmes d’exploitation.
Et le principe n’a pas disparu. Aujourd’hui encore, de nombreuses tâches sont exécutées automatiquement en arrière-plan : traitements bancaires, sauvegardes, génération de rapports, calculs scientifiques ou traitement de grandes quantités de données.
Le batch n’est donc pas seulement une technique des années 1950 : c’est un modèle d’exécution qui reste encore largement utilisé.
