 |
Vendredi 23 mai 2025 - 10:57 |
| Translate |
|
| Rubriques |
| Réseaux sociaux |
|
| Liste des jeux Amiga |
|
| Trucs et astuces |
|
| Glossaire |
|
| Galeries |
|
| Téléchargement |
|
| Liens |
|
| Partenaires |
|
| A Propos |
|
| Contact |
|
|
|
Avant-propos (par Jane Morrill Tazelaar)
Le multitâche est l'équivalent informatique de la marche et du chewing-gum, c'est-à-dire la capacité à faire plus d'une chose à la fois. Les mini-ordinateurs et les ordinateurs centraux sont multitâches depuis des années, et les micro-ordinateurs gagnent maintenant du terrain sur eux.
Plus nos machines deviennent rapides et efficaces, plus nous semblons impatients. Les temps d'attente nous paraissent interminables lorsqu'ils sont de l'ordre de la minute, surtout lorsque cette attente signifie que nous devons rester assis sans rien faire pendant que l'ordinateur travaille. Nous voulons pouvoir dire à nos machines ce qu'elles doivent faire, puis oublier cette tâche et passer à autre chose pendant que l'ordinateur s'occupe à la fois de cette tâche interne et du travail que nous sommes en train d'effectuer.
C'est là qu'intervient le multitâche, qui fait l'objet de cet article. Le multitâche implique le partage des ressources. La partie de ce présent article intitulée "Partage équitable", de Jonathan Robie, traite de toutes les combinaisons et permutations que ce partage peut englober. Jonathan Robie explique les différentes parties du multitâche, les divers moyens de programmer les tâches et la communication nécessaire entre les tâches pour que tout se déroule de manière ordonnée. Il aborde également certains des problèmes que vous pouvez rencontrer lorsque vous essayez de faire plus d'une chose à la fois.
Certains microprocesseur sont en fait conçus pour le multitâche - en fait, avec le multitâche intégré. La puce 80386 est l'une d'entre elles. Dans l'article "It's a Natural" (Byte de juillet 1987), Bud E. Smith explore certains des éléments internes qui donnent à cette puce une longueur d'avance en matière de multitâche, notamment la gestion matérielle de la pagination et de la mémoire virtuelle.
Les machines 80386 ne sont cependant pas la seule option pour le multitâche, loin s'en faut. L'Amiga est équipé d'un système multitâche et le nouveau système d'exploitation du Macintosh, MultiFinder, est également conçu pour cela. Dans la partie de ce présent article intitulé "Peser les différentes options", Brett Glass examine les nombreux systèmes disponibles et les compare en fonction de leurs capacités et de la façon dont ils choisissent de gérer les différentes fonctions du multitâche.
Une fois de plus, les micro-ordinateurs pénètrent dans ce qui était autrefois le domaine exclusif des mini-ordinateurs et des ordinateurs centraux, et une fois de plus, nous en sortons vainqueurs.
Partage équitable (par Jonathan Robie)
Dans un système multitâche, c'est le partage des ressources qui détermine la réussite ou l'échec de vos applications.
L'efficacité n'a pas la même signification pour tout le monde. Le multitâche est un moyen d'utiliser l'ordinateur plus efficacement en partageant à la fois l'ordinateur et ses ressources entre les programmes. De nombreuses stratégies multitâches différentes ont évolué, chacune d'entre elles optimisant les éléments les plus importants pour le concepteur du système. Certaines approches ont évolué pour optimiser l'utilisation de l'ordinateur, d'autres pour permettre de résoudre plus facilement certains problèmes de programmation, et d'autres encore pour vous permettre de continuer à travailler sur l'ordinateur même lorsque de longs travaux sont en cours d'exécution.
Le multitâche est apparu sur les premiers ordinateurs centraux comme un moyen d'utiliser efficacement des ressources informatiques coûteuses. Lorsqu'un programme effectuait des opérations d'entrées/sorties relativement lentes, il ne pouvait pas poursuivre son exécution jusqu'à ce que l'opération d'entrées/sorties soit terminée. Cela gaspillait la puissance du processeur pendant les entrées/sorties. Dans le cas du traitement des données commerciales, ce temps d'attente des entrées/sorties représentait souvent entre 80 et 90% du temps d'exécution total. Un système d'exploitation multitâche prend le processeur du programme qui attend les entrées/sorties et le donne à un autre programme qui est prêt à l'utiliser. Si la mémoire contient suffisamment de tâches, il est possible d'utiliser le processeur la plupart du temps. Cette forme de multitâche, appelée "multiprogrammation", a permis d'améliorer considérablement le débit des ordinateurs. Mais cette amélioration a un coût : bien qu'un plus grand nombre de programmes puissent être exécutés, chacun d'entre eux prenait plus de temps. À cette époque, la plupart des programmeurs rêvaient d'un ordinateur qu'ils n'auraient pas à partager.
Sur les mini-ordinateurs, Unix a fourni aux programmeurs un modèle simple pour le multitâche. Au début, ce modèle était principalement utilisé au niveau du système d'exploitation, mais les programmeurs ont rapidement réalisé que cet outil pouvait les aider à simplifier de nombreux programmes complexes.
Le multitâche sur les micro-ordinateurs a évolué comme une commodité pour l'utilisateur. Il est devenu si populaire que presque tous les micro-ordinateurs modernes disposent d'un système d'exploitation ou d'un programme personnalisé qui en permet une forme ou une autre. La compilation d'un programme, le téléchargement d'un fichier et le tri d'un grand tableau dans une base de données ont tous un point commun : ils peuvent monopoliser l'ordinateur pendant un certain temps. La plupart d'entre nous détestent attendre. Le multitâche nous permet de continuer à travailler pendant qu'une autre tâche est en cours d'exécution. Comme les différents types de programmes sollicitent différemment l'ordinateur, il est souvent possible de combiner plusieurs programmes sans ralentir considérablement les performances. Par exemple, j'ai découvert que je pouvais effectuer des communications en arrière-plan avec RamNet pendant que je compilais et reliais de gros programmes sans que cela ne modifie de manière significative le temps nécessaire à la compilation et à l'édition de liens.
De nombreuses personnes qui ont dû partager un ordinateur avec d'autres sont surprises d'apprendre que le multitâche peut rendre leur travail plus efficace.
Si je peux me permettre d'interrompre...
La forme la plus simple du multitâche est appelée "multitâche en série", ou simple changement de contexte. Il s'agit simplement d'interrompre temporairement une tâche pour travailler sur une autre. Si vous avez utilisé Macintosh Desktop ou SideKick, vous avez utilisé le multitâche en série. Alors qu'un programme est en cours d'exécution, vous décidez d'utiliser la calculatrice, vous ouvrez donc la calculatrice et vous l'utilisez. Lorsque vous cessez d'utiliser la calculatrice, le programme continue à fonctionner. Cela s'apparente à la manière dont beaucoup d'entre nous travaillent : pendant que je programme, je m'arrête souvent pour répondre au téléphone, boire une tasse de café ou nettoyer mes lunettes. Ensuite, je poursuis mon travail.
Pour changer de contexte, vous devez disposer d'un moyen d'interrompre le programme en cours d'exécution et de vous souvenir de tout ce qui est nécessaire pour poursuivre le travail ultérieurement : le programme et toutes les données en cours, ainsi que toutes les informations qui se trouvaient dans les registres de l'ordinateur lorsque le programme a été interrompu. Ces informations sont appelées l'image du processus. L'ordinateur utilise un ou plusieurs de ses registres pour savoir quelle instruction du programme doit être exécutée ensuite, de sorte que cette information est également préservée lorsque vous sauvegardez les registres. Par conséquent, si le programme et ses données sont toujours en mémoire (et à l'emplacement d'origine), vous pouvez relancer le programme en restaurant le contenu des registres.
Les utilitaires fenêtrés de MS-DOS utilisent généralement un appel DOS pour se terminer et rester résident, c'est-à-dire pour rester en mémoire et mettre à jour le DOS afin qu'il n'essaie pas de placer un autre programme au même endroit. Les programmes qui font cela sont appelés TSR. Ils installent un gestionnaire d'interruption du clavier qui recherche des combinaisons de touches spéciales. Lorsqu'il détecte la combinaison de touches appropriée, il enregistre tous les registres et passe le contrôle au TSR. Lorsque vous avez terminé avec le TSR, les registres sont restaurés et le programme d'origine reprend là où il s'est arrêté.
Le temps en tranches
Si le multitâche en série peut vous aider à travailler plus efficacement, il fait travailler l'ordinateur beaucoup moins efficacement. Si l'ordinateur est en train d'effectuer des calculs lorsque vous l'interrompez, tout le travail sur ces calculs s'arrête. Si vous l'avez interrompu pour faire du traitement de texte ou pour utiliser la calculatrice, vous n'utilisez qu'une petite fraction de sa puissance, mais aucune des capacités excédentaires n'est utilisée pour poursuivre le travail sur le programme initial. Il serait bon de n'accorder au nouveau programme qu'une partie du temps de l'ordinateur et d'utiliser le reste pour poursuivre les calculs. Vous pourriez écrire un programme appelé "scheduler" (ordonnanceur) pour déterminer quel programme doit être exécuté à un moment donné. Mais vous ne pouvez le faire que si vous trouvez un moyen de diviser le temps sur l'ordinateur.
Pratiquement tous les systèmes d'exploitation multitâches fonctionnent sur des ordinateurs dotés d'une forme ou d'une autre d'interruption de temporisation, qui génère une interruption à un intervalle fixe. Sur l'IBM PC et ses clones, cette interruption se produit environ 18 fois par seconde. Sur de nombreux autres ordinateurs, elle se produit entre 50 et 60 fois par seconde.
Vous pouvez utiliser cette interruption de temporisation pour vous assurer que l'ordonnanceur prend le contrôle après que chaque programme a été exécuté pendant une période de temps spécifiée. Cette période, appelée "quantum" ou "tranche de temps", doit être un multiple de l'intervalle entre les interruptions de la minuterie afin que vous disposiez d'un mécanisme pour la faire respecter. Si vous donnez à chaque programme suffisamment de tranches de temps chaque seconde, vous aurez l'impression que tous les programmes s'exécutent en même temps, mais chaque programme s'exécutera plus lentement qu'il ne le ferait en l'absence de multitâche.
Maintenant que vous pouvez diviser le temps du processeur et l'allouer à différents programmes, vous devez décider du temps à accorder à chaque programme et du moment où vous le ferez. C'est ce qu'on appelle l'ordonnancement du processeur, sujet qui a fait couler beaucoup d'encre. Étant donné qu'il est impossible de prendre ces décisions sans objectif concret, permettez-moi de proposer quelques objectifs largement acceptés pour les algorithmes d'ordonnancement.
- Maximiser l'utilisation du processeur.
- Maximiser le nombre de tâches traitées par heure.
- Terminer chaque programme le plus rapidement possible.
- S'assurer que le temps nécessaire à l'exécution d'un programme donné est toujours constant.
- Minimiser le temps de réponse pour les utilisateurs interactifs.
Les algorithmes d'ordonnancement sont comme tout le reste : vous devez décider ce qui est le plus important et dans quelle mesure vous pouvez sacrifier d'autres éléments souhaitables. Il n'est donc pas surprenant que des systèmes différents affichent des valeurs différentes et utilisent des algorithmes d'ordonnancement différents. Je vais examiner deux des algorithmes d'ordonnancement les plus couramment utilisés, le round-robin et l'ordonnancement simple basé sur les priorités.
C'est mon tour
Une approche consiste à faire en sorte que tous les processus soient exécutés à tour de rôle. Chaque processus en cours d'exécution peut fonctionner pendant une tranche de temps. Il doit ensuite attendre que tous les autres processus aient eu leur tour avant de recevoir sa tranche de temps suivante. Cette approche, appelée round-robin, est éminemment équitable. Elle est particulièrement bien adaptée au partage équitable de l'ordinateur entre les utilisateurs interactifs.
La principale question de conception de l'ordonnancement round-robin est la taille de la tranche de temps. Si elle est trop grande, les tâches sont obligées d'attendre trop longtemps pour permettre une utilisation interactive. Si elle est trop courte, les surcharges processeur liés au passage d'un programme à l'autre dépassent le temps disponible pour les exécuter.
Les VIP passent en premier
Le système round-robin suppose que tous les programmes ont la même importance, mais cette hypothèse n'est pas toujours utile. Par exemple, vous pouvez vouloir vous assurer que les processus interactifs ont une priorité très élevée afin que vous puissiez toujours travailler sur votre ordinateur, même si de nombreux programmes longs sont en cours d'exécution. Dans les environnements multi-utilisateurs, les systèmes de priorité sont souvent utilisés pour donner la priorité à une catégorie d'utilisateurs par rapport à une autre.
Dans un schéma de priorité, chaque programme reçoit un code de priorité. S'il n'y a qu'un seul processeur et qu'un programme a le code de priorité le plus élevé, c'est ce programme qui bénéficie du processeur. Si plusieurs processus ont le même code de priorité, ce système met en oeuvre un algorithme d'ordonnancement round-robin entre eux.
Cet algorithme de priorité simple est précisément celui du Commodore Amiga. L'implémentation originale d'Unix a un schéma similaire, mais tous les processus du système sont garantis d'avoir la priorité sur les processus de l'utilisateur. Unix modifie dynamiquement la priorité des processus utilisateur pour s'assurer que les processus interactifs sont prioritaires. OS/2 utilise un schéma légèrement plus compliqué qui divise les tâches en plusieurs classes en fonction d'une série de facteurs. Comme Unix, il modifie également la priorité des processus utilisateur pour favoriser les processus interactifs.
Mélanger les choses
Quel que soit l'algorithme d'ordonnancement, il n'est presque jamais utile de permettre à un processus d'occuper le processeur pendant qu'il attend que quelque chose se passe. L'attente en boucle d'un événement s'appelle l'attente occupée ("busy waiting"). Il s'agit d'un péché capital dans le monde du multitâche, car il vole du temps précieux du processeur à d'autres processus qui pourraient l'utiliser. Les entrées/sorties étant généralement lentes, les programmes abandonnent presque toujours le processeur lorsqu'ils effectuent des entrées/sorties.
La plupart des systèmes multitâches cherchent à maintenir les périphériques de l'ordinateur occupés ; ces systèmes favorisent les processus qui abandonnent rapidement le processeur afin de commencer les entrées/sorties. Étant donné que les entrées/sorties peuvent généralement être effectuées pendant que le processeur fait autre chose, le débit s'en trouve accru. Si le périphérique n'est pas disponible, le système se souvient qu'il y a un programme qui a besoin du périphérique dès qu'il est libre.
Bien entendu, si tous les programmes sont fortement liés aux entrées/sorties, le processeur peut rester inactif pendant que les programmes attendent les entrées/sorties. Les systèmes multitâches sont plus efficaces lorsqu'il y a un mélange de programmes liés au processeur et de programmes liés aux entrées/sorties. Dans de nombreux systèmes orientés "batch", un autre ordonnanceur, appelé ordonnanceur à long terme, cherche à choisir un mélange approprié de programmes pour utiliser l'ordinateur de manière optimale.
Blocage de l'exécution
Jusqu'à présent, j'ai abordé le traitement des programmes. Mais un programme peut en fait consister en un certain nombre de tâches qui fonctionnent "en parallèle" et qui sont programmées séparément (en fait, elles ne fonctionnent pas en parallèle, mais le multitâche donne l'illusion du parallélisme). Par exemple, un traitement de texte peut contenir une tâche qui accepte l'entrée de l'utilisateur et une autre qui exécute un correcteur d'orthographe avec une priorité moindre. Chaque tâche dispose de sa propre mémoire, de son propre registre et de ses propres ressources.
Les termes "processus" et "tâche" peuvent être utilisés indifféremment. J'appellerai tâche en cours d'exécution la tâche qui dispose actuellement du processeur. Si elle attend qu'un événement se produise (par exemple, qu'une entrée/sortie se termine), je la qualifierai de bloquée. Si elle n'est pas bloquée et qu'elle ne dispose pas du processeur, je la qualifierai de tâche prête (voir figure 1).
Figure 1 : les différents changements d'état qui peuvent se produire
lorsqu'une tâche se déroule du début à la fin.
Parler à l'autre
Le multitâche a évolué comme une construction de système d'exploitation, mais c'est aussi un modèle extrêmement puissant pour construire des systèmes logiciels complexes. En utilisant des primitives multitâches, vous pouvez laisser à l'environnement de programmation le soin de mélanger des tâches distinctes et programmer à un niveau conceptuel plus élevé.
Vous pourriez utiliser cette capacité pour écrire un paquet de télécommunications pour des services commerciaux de babillards électroniques comme BIX. Le temps de connexion étant coûteux, il est préférable de se connecter et de se déconnecter des babillards électroniques aussi rapidement que possible. Le programme doit se connecter, rassembler tous les messages dans un fichier, télécharger le fichier et se déconnecter. Malheureusement, le téléchargement a tendance à être lent, ce qui oblige le programme à attendre. Étant donné que la lecture et le commentaire des messages sont encore plus lents, vous aimeriez pouvoir effectuer ces fonctions pendant le téléchargement. Vous auriez ainsi la sensation d'un système interactif avec les frais de connexion d'un téléchargement par lots.
Sans un environnement multitâche, ce serait compliqué : il faudrait déterminer quand appeler les routines de téléchargement, de visualisation et de commentaire. Ce type de programme est difficile à structurer correctement sans tâches multiples.
Dans un environnement multitâche, la solution est un peu plus simple. Vous pouvez créer deux tâches : la première appelle le babillard électronique, télécharge les données et se déconnecte ; la seconde affiche les messages et vous permet d'ajouter des réponses à l'aide d'un éditeur spécial. Vous pouvez ensuite réactiver la première tâche pour afficher vos réponses aux endroits appropriés sur le babillard électronique.
Ces deux tâches doivent communiquer pour fonctionner efficacement. D'une part, elles écriront toutes deux des informations sur la ligne d'état ; si ces messages se mélangent, l'affichage sera confus. Si vous créez un sémaphore pour la ligne d'état, vous pouvez vous assurer qu'un seul processus utilisera la ligne à la fois.
Le second type de communication est plus intéressant et plus complexe : la tâche d'affichage doit recevoir toutes ses données de la tâche de télécommunications ; cette dernière doit informer la tâche d'affichage de l'arrivée de nouvelles données et de leur quantité. Elle peut également communiquer d'autres informations sur l'état et le format des messages.
Pour ce type de communication, les boîtes aux lettres ("mailboxes") ou les tuyaux ("pipes") sont appropriés. Ces termes sont utilisés différemment selon les systèmes, et une discussion approfondie devrait délimiter les différences de terminologie. Pour ce qui me concerne, j'utiliserai ces termes de manière générale pour indiquer un moyen de passer des messages d'une tâche à une autre.
L'Amiga réalise le passage de messages avec des messages et des ports ; OS/2 et Unix le font avec des tuyaux de différentes sortes. Tout système multitâche à part entière doit permettre aux tâches d'échanger des messages.
Enfin, la tâche de télécommunications doit transmettre les messages téléchargés à la tâche d'affichage. Vous pourriez le faire avec un seul fichier, mais cela pourrait être lent si vous échangez de grandes quantités de données. Vous pouvez également le faire par l'intermédiaire d'un tuyau ou d'une boîte aux lettres, ce qui est plus rapide. Vous pouvez aussi utiliser la mémoire partagée, qui est encore plus rapide ; c'est ce qu'utilise OS/2. Deux processus peuvent partager un segment de mémoire afin que la tâche d'affichage puisse avoir accès à un tampon mémoire utilisé par la tâche de télécommunications.
Le planificateur de tâches spécifie quand appeler chaque tâche. Étant donné que les protocoles de téléchargement sont soumis à des contraintes de temps, il est essentiel d'accorder à la tâche de télécommunications une priorité suffisamment élevée pour qu'elle s'exécute rapidement. Il faut également que le temps de réponse soit rapide. L'équilibre des priorités est essentiel au fonctionnement de ce système. L'utilisation du système multitâche vous offre une flexibilité accrue - la plupart des solutions codées en dur à ce type de problème ne vous permettent pas facilement de changer les priorités ou de modifier les relations entre les modules.
Partager et faire partager
Quand les ordinateurs étaient très chers, le multitâche permettait de maximiser le nombre de programmes que l'on pouvait exécuter. Quand les ordinateurs sont devenus moins chers, le multitâche a rendu les programmeurs plus efficaces en leur offrant un meilleur environnement de programmation et un meilleur modèle de programmation. Dans le monde orienté utilisateur des micro-ordinateurs, le multitâche vous permet d'utiliser votre temps de manière plus efficace.
Avec le multitâche, vous pouvez choisir de maximiser le débit de l'ordinateur ou de minimiser l'attente des personnes concernées, mais vous ne pouvez probablement pas faire les deux. Vous pouvez également utiliser le multitâche pour fournir un modèle de programmation pratique pour les systèmes logiciels complexes. Le type de multitâche que vous choisissez et les paramètres que vous utilisez pour cette implémentation détermineront dans quelle mesure votre système répond à vos besoins.
Bibliographie
- Amiga ROM Kernel Reference Manual: Exec. Reading, MA : Addison- Wesley, 1986.
- Deitel, Harvey M. An Introduction to Operating Systems. Reading, MA : AddisonWesley, 1984.
- Manuel de DESQview. Santa Monica, CA : Quarterdeck Office Systems.
- "In Depth: Memory Management." Byte. April, 1988.
- Letwin, Gordon. Inside OS/2. Redmond, WA : Microsoft Press, 1988.
- Lions, J.A Commentary On The Unix Operating System. Dept. Of Computer Science, Univ. Of New South Wales, 1977.
- Tanenbaum, Andrew S. Operating Systems: Design & Implementation. Englewood Cliffs, NJ : Prentice Hall, 1987.
Au sens large, le multitâche est la capacité d'exécuter plus d'un programme, ou plusieurs copies du même programme, en même temps. Longtemps réservée aux coûteux mini-ordinateurs et ordinateurs centraux, cette capacité est aujourd'hui devenue une caractéristique souhaitable pour tous les systèmes informatiques, indépendamment de leur taille ou de leur coût.
Le multitâche dans les ordinateurs centraux était un produit de la nécessité économique : la puissance de calcul était une ressource trop rare et trop chère pour être gaspillée. Cependant, dans le monde des micro-ordinateurs, le passage au multitâche a été principalement motivé par le désir d'une plus grande commodité et d'un accroissement de la productivité personnelle. Dans le texte qui suit, je vais explorer les caractéristiques et les limites de certains des environnements multitâches les plus populaires disponibles aujourd'hui pour les ordinateurs personnels.
Contrairement à ce que l'on pourrait penser, le multitâche n'est pas une nouveauté sur les petits ordinateurs personnels. Dès le milieu des années 1970, des fournisseurs ont proposé des environnements tels que Cromix de Cromemco, un système d'exploitation de type Unix hébergé par un processeur Z80 de 4 MHz avec une mémoire à commutation de banques. Mais l'écrasante majorité des micro-ordinateurs disponibles aujourd'hui, tels que l'IBM PC et l'Apple Macintosh, n'ont pas été conçus à l'origine avec des capacités multitâches complètes à l'esprit.
Pour ces systèmes, la technologie permettant l'utilisation simultanée de plusieurs programmes a évolué en trois étapes : accessoires de bureau (appelés TSR dans le monde du PC IBM à partir de l'appel MS-DOS "Terminate-and-Stay-Resident"), commutateurs de programmes et environnements multitâches complets. Dans le même temps, les fabricants (et, dans certains cas, des tiers innovants) ont commencé à réorganiser le matériel et les logiciels existants pour qu'ils soient multitâches de par leur conception, et non pas après coup.
Commutateurs de programmes supplémentaires
Les premiers ordinateurs personnels n'exécutaient qu'un seul programme à la fois. Si, par exemple, vous exécutiez un programme de base de données et souhaitiez apporter une modification rapide à un document de traitement de texte, il n'y avait pas d'autre moyen de le faire que d'enregistrer votre travail, de quitter l'application de base de données, d'entrer dans le programme de traitement de texte et de faire apparaître le document. Sur les ordinateurs à disquettes, cette opération pouvait nécessiter un changement de disquette et prenait certainement assez de temps pour vous faire oublier l'idée pour laquelle vous faisiez cela.
Des développeurs astucieux ont perçu ce problème et ont commencé à trouver des solutions. Le résultat a été un petit programme appelé "desk acessory" (accessoire de bureau) qui peut instantanément "surgir" en cas de besoin, quelle que soit l'application en cours d'exécution. Des exemples de ces programmes sont SideKick pour les PC IBM et l'accessoire de bureau MockWrite pour le Macintosh.
Bien que ces accessoires de bureau ne permettent pas au programme principal de fonctionner pendant qu'ils sont à l'écran, ils vous permettent d'enregistrer une idée dans un fichier sans quitter votre base de données, ou de faire apparaître le programme de la journée sans quitter votre traitement de texte. Les capacités limitées mais utiles des accessoires de bureau ont amené leurs utilisateurs à se demander "s'il est possible de faire apparaître un petit programme en cas de besoin, pourquoi pas une application complète de mon choix ?". Les développeurs ont à nouveau répondu à cette question en créant une nouvelle catégorie d'utilitaires : les commutateurs de programmes.
Un commutateur de programmes vous permet de passer rapidement d'une application à l'autre sans avoir à recharger chaque programme ou à sauvegarder votre travail. Chacun de ces utilitaires permet de passer d'un programme à l'autre, bien qu'il soit important de noter que le programme activé "possède" l'ensemble de la machine tant qu'il fonctionne, tandis que les programmes désactivés sont inactifs. Parmi les exemples, citons Switcher d'Andy Hertzfeld pour le Macintosh et un certain nombre de programmes pour le PC IBM, tels que Multiple Choice de Jason Loveman, Software Carousel de SoftLogic Solutions et DESQ de Quarterdeck.
Enfin, les développeurs ont commencé à s'attaquer à la tâche redoutable consistant à faire en sorte que plusieurs programmes semblent s'exécuter non pas un à la fois, mais simultanément, sur le même système. Ces environnements sont appelés "multitâches complémentaires" (add-on multitaskers). Le MultiFinder d'Apple a commencé comme un commutateur de programmes qui changeait simplement de programmes de façon répétée (et très rapidement), et a été affiné plus tard pour effectuer un multitâche plus "intelligent". Dans le monde des PC IBM, TopView, Wendin-DOS, Microsoft Windows et DESQview ont rendu possible le multitâche (sous réserve des limitations architecturales). L'apparition du processeur 80386 dans les machines de la classe IBM rend enfin possible le multitâche des applications existantes dans des environnements tels que PC-MOS/386, Windows/386 et DESQview.
Le multitâche dès la conception
Tandis que certains développeurs s'efforçaient de faire du multitâche avec des programmes qui n'avaient jamais été écrits pour partager une machine avec une autre application, d'autres développaient des environnements nouveaux et complets qui étaient conçus dès le départ pour faire fonctionner plusieurs applications simultanément. Sur le PC d'IBM se trouvaient des portages d'Unix et de PICK, deux environnements multitâches bien établis sur mini-ordinateurs, ainsi que de nouveaux systèmes tels que OS/2.
En raison de sa complexité et de la nature propriétaire de son fonctionnement interne, peu de tiers ont tenté de développer de nouveaux environnements d'exploitation pour le Macintosh. Toutefois, le nouveau Mac II, s'il est équipé des ressources et de la puce de gestion de la mémoire appropriées, fait tourner une version d'Unix fournie par Apple et connue sous le nom d'A/UX.
De nombreux systèmes multitâches pour les machines existantes gèrent un mécanisme permettant d'exécuter une ou plusieurs "anciennes" applications, de sorte que vous puissiez migrer gracieusement d'un environnement à l'autre. Le Merge 386 de Micropores et le VP/ix 386 de Phoenix Technologies permettent aux applications MS-DOS de fonctionner sous leurs versions respectives d'Unix pour IBM PC. QNX, un sosie d'Unix pour PC, gère MS-DOS en tant que tâche. La boîte de compatibilité OS/2 vous permet d'exécuter une seule application MS-DOS en même temps que plusieurs nouvelles applications. Enfin, le système A/UX d'Apple offre une possibilité limitée de lancer des applications Macintosh conventionnelles à partir de l'environnement Unix.
Enfin, il y a les combinaisons machine/système d'exploitation les plus récentes où le multitâche est une caractéristique incluse dès la conception du matériel. L'Amiga de Commodore est le plus connu de ces systèmes dans le monde des micro-ordinateurs. Doté d'un matériel graphique spécial conçu pour gérer les tâches exécutées sur plusieurs écrans et fenêtres, l'Amiga est au moins partiellement responsable de la ruée vers le multitâche sur les autres PC.
Quelle est la différence ?
Les mots "multiprogrammation", "multiprocessus" et "multitâche" sont souvent confondus. Avant de poursuivre, j'aimerais établir quelques distinctions entre ces termes similaires, mais distincts.
Le terme "multiprogrammation" fait référence à la situation dans laquelle un seul processeur partage son temps entre plusieurs tâches. Le partage du temps est un cas particulier de multiprogrammation, dans lequel un seul processeur sert un certain nombre d'utilisateurs sur des terminaux interactifs.
Avec le "multiprocessus", plusieurs processeurs effectuent plusieurs tâches à la fois. Le multiprocessus et la multiprogrammation ne s'excluent pas mutuellement : certains ordinateurs centraux et superordinateurs sont dotés de plusieurs processeurs, chacune d'entre elles pouvant jongler avec plusieurs tâches.
Certaines sources considèrent que le "multitâche" est équivalent à la multiprogrammation. D'autres le définissent comme toute situation impliquant la multiprogrammation, le multiprocessus ou une combinaison des deux. Dans le cadre de cet article, j'utiliserai le terme multitâche pour décrire tout système qui exécute, ou semble exécuter, plus d'un programme d'application à la fois.
Un environnement multitâche efficace doit fournir de nombreux services, tant à l'utilisateur qu'aux programmes d'application qu'il exécute. Les plus importants sont la gestion des ressources, qui répartit le temps, la mémoire et les périphériques de l'ordinateur entre des tâches concurrentes, et la communication interprocessus, qui permet aux tâches de coordonner leurs activités en échangeant des informations.
Partage du processeur
La ressource clé que tous les environnements multitâches doivent gérer, ou planifier, est l'utilisation du processeur lui-même. Bien qu'il existe de nombreux systèmes permettant de répartir le temps d'utilisation du processeur entre les différentes tâches d'un système, tous se répartissent en deux catégories principales : l'ordonnancement préemptif et l'ordonnancement non préemptif.
Dans l'ordonnancement préemptif, une tâche peut perdre le contrôle du processeur à tout moment et une autre tâche est exécutée à sa place. La tâche qui perd le contrôle, ou qui est préemptée, n'a pas besoin de savoir que cela s'est produit ; en fait, elle peut même ne pas savoir qu'elle s'exécute dans un environnement multitâche. Pour ce faire, le matériel et les logiciels du système sont conçus pour faire croire à la tâche qu'elle est propriétaire de la machine.
La plupart des algorithmes de planification préemptive accordent aux tâches interactives des tranches de temps plus importantes et plus fréquentes afin qu'elles puissent répondre rapidement à la demande d'un utilisateur. Étant donné que le niveau d'interaction peut varier dans les différentes parties d'un même programme (par exemple, une feuille de calcul nécessite un niveau élevé d'interaction pendant la saisie des données, mais aucune pendant le recalcul), de nombreux environnements sont conçus pour surveiller le comportement actuel de chaque tâche et ajuster sa tranche de temps de manière appropriée.
Dans l'ordonnancement non préemptif (également appelé "multitâche coopératif"), une tâche qui prend le contrôle du processeur continue à le faire pendant un certain temps jusqu'à ce qu'elle cède explicitement le contrôle à la tâche suivante. Bien que les ordonnanceurs non préemptifs soient généralement très simples à implémenter, ils ne sont généralement pas aussi robustes ou tolérants aux erreurs que les ordonnanceurs préemptifs. Avec un ordonnancement non préemptif, une tâche qui ne parvient pas à céder le contrôle du processeur - en raison d'un bogue logiciel ou d'un problème matériel - bloque l'ensemble du système, détruisant toutes les données utilisées par chaque tâche. De même, une tâche qui cède trop rarement le contrôle à d'autres tâches actives donne l'impression que le système entier est lent. En pratique, l'ordonnancement non préemptif fonctionne mieux lorsqu'il est appliqué soit par le compilateur qui crée le programme, soit par des normes de conception de programme rigoureuses.
Enfin, dans le domaine de la gestion du temps, un ordonnanceur doit déterminer quelle tâche doit être exécutée ensuite, et pendant combien de temps. Un ordonnanceur préemptif peut interrompre une tâche lorsqu'il y a quelque chose de plus important à faire (par exemple, gérer un périphérique), et les ordonnanceurs préemptifs et non préemptifs peuvent déterminer la fréquence d'exécution de chaque tâche. D'une manière générale, il est souhaitable de donner à la tâche qui occupe la fenêtre la plus en avant dans un environnement fenêtré la priorité sur celles qui se trouvent dans les autres fenêtres, car cela améliore la réactivité du système telle qu'elle est perçue par l'utilisateur.
À l'autre extrême, les systèmes multitâches doivent également empêcher la "privation", c'est-à-dire la situation dans laquelle une tâche ne s'exécute jamais parce que sa priorité est trop faible. OS/2, par exemple, fixe une durée maximale pendant laquelle une tâche, quelle que soit sa priorité, peut languir sans prendre le contrôle du processeur.
Partage de la mémoire
Outre le partage du temps du processeur, tous les environnements multitâches doivent aider les applications à partager la mémoire vive disponible entre elles. Les trois principales fonctions qu'un environnement peut fournir sont l'allocation de mémoire (requise sur toutes les machines), le surengagement de la mémoire (également appelé permutation ou pagination) et la protection (disponible uniquement lorsque le matériel le permet).
Dans un système multitâche, chaque tâche doit être reléguée à une partie spécifique de la mémoire, et chaque tâche ne doit pas essayer de manipuler la mémoire appartenant à d'autres tâches sans autorisation. Dans les systèmes conçus dès le départ pour le multitâche, les tâches sont censées demander de la mémoire au système d'exploitation avant de l'utiliser. Dans les environnements multitâches complémentaires, le système "ment" souvent à une tâche en lui disant que le système dispose de moins de mémoire qu'il n'en a en réalité. Ainsi, une tâche qui réquisitionne toute la mémoire disponible s'exécute toujours correctement. Certains systèmes permettent également d'arrêter temporairement une tâche et de copier sa mémoire sur le disque, ce qui laisse de la place pour d'autres tâches pendant que la première est en sommeil.
Lorsqu'une tâche interfère avec d'autres en accédant directement à des éléments clés du matériel d'une machine (comme l'écran), il se peut qu'elle ne puisse pas fonctionner simultanément avec d'autres applications dans un environnement multitâche. Microsoft Windows 2.0 et DESQview (sans 80386) permettent d'activer et de désactiver ces applications, soit en les transférant sur le disque, soit en les laissant inactives dans la mémoire vive lorsqu'elles ne sont pas utilisées.
La mise en sommeil d'une tâche et le transfert de sa mémoire sur le disque constituent une forme primitive de surengagement de la mémoire, c'est-à-dire l'exécution d'un nombre de tâches supérieur à celui que peut contenir la mémoire vive à un moment donné. Cependant, pour surcharger la mémoire sans suspendre au moins une tâche, il faut généralement un matériel spécial appelé "unité de gestion de la mémoire" (MMU). Les ordinateurs personnels populaires qui contiennent des MMU comprennent l'IBM PC AT, les compatibles AT et le Macintosh II (en tant qu'option supplémentaire). L'IBM PC XT, tous les Macintosh développés avant le Mac II et l'Amiga ne contiennent pas de MMU.
Une MMU facilite le surengagement de la mémoire en détectant rapidement et automatiquement lorsqu'un programme tente d'accéder à des informations qui ne se trouvent pas dans la mémoire. Lorsqu'elle détecte un tel accès, elle active un logiciel spécial qui lit l'information nécessaire sur le disque, puis redémarre le programme là où il s'est arrêté. Le programme qui a tenté d'accéder à l'information ne se rend pas compte que quelque chose d'inhabituel s'est produit. L'exécution se poursuit exactement comme si les données se trouvaient dans la mémoire depuis le début, mais peut-être un peu plus lentement.
Certains systèmes dépourvus de MMU, tels que Windows sur PC et le Macintosh, ont une capacité limitée à surcharger la mémoire. La mémoire occupée par certaines parties du code ("segments") et par des blocs de données qui ne changent pas ("ressources") peut être désallouée, ou purgée, et réutilisée à d'autres fins.
Une autre fonction utile dans les systèmes multitâches est la protection de la mémoire, c'est-à-dire l'interdiction faite aux programmes de lire ou de modifier la mémoire vive qui ne leur appartient pas. Cette protection permet de limiter les dégâts causés par un programme bloqué et, en général, les informations manipulées par d'autres programmes restent intactes. Une MMU fournit également une protection de la mémoire de ce niveau.
Le processeur 80386 dispose de moyens particulièrement puissants pour la protection de la mémoire. De nombreux programmes "mal élevés" (c'est-à-dire des programmes qui prennent le contrôle de tout ou partie du matériel du PC) peuvent être contenus en toute sécurité dans une machine virtuelle et empêchés d'interférer avec d'autres applications. DESQview, Microsoft Windows/386, Merge 386 et VP/ix utilisent tous cette fonction sur une seule machine à base de 80386 pour exécuter plusieurs programmes PC (et, dans les deux derniers cas, des applications Unix).
Enfin, les systèmes multitâches contrôlent également l'accès aux ressources telles que les imprimantes, les ports série, les fichiers de disque et l'écran de l'ordinateur. Souvent, un système met en mémoire ("spool") la sortie de l'imprimante en sauvegardant les informations générées par chaque programme et en les imprimant séparément, plutôt que d'imposer un accès exclusif ("spool" signifie d'ailleurs "simultaneous peripheral operation on-line"). Des parties de fichiers disque peuvent être verrouillées pour empêcher l'accès simultané à plus d'une tâche. De même, l'écran peut être divisé en fenêtres afin que vous puissiez visualiser simultanément les résultats de plusieurs programmes.
Communication interprocessus
Un environnement multitâche devient beaucoup plus utile si les tâches, ou processus, peuvent communiquer entre eux. Bien que le nombre de mécanismes de communication possibles soit infini, un nombre relativement restreint d'entre eux ont été largement acceptés. Il s'agit des sémaphores, des tuyaux, des files d'attente, des messages, des signaux, des tuyaux nommés, de la mémoire partagée et des interfaces de connexion ("sockets").
Un sémaphore est simplement une variable (un entier ou un drapeau oui/non) qui peut être lue, incrémentée ou décrémentée par plus d'un processus. La plupart des implémentations fournissent un moyen de tenter de modifier la variable et de récupérer sa valeur originale en une seule opération indivisible ; cette fonctionnalité est nécessaire pour éviter les "situation de compétition" lorsque deux processus tentent de manipuler le sémaphore en même temps.
Un tuyau ("pipe") est un mécanisme qui permet de transmettre un flux de caractères d'une tâche à une autre dans l'ordre. Les tuyaux sont un mécanisme de communication à sens unique : les données circulent toujours de l'extrémité d'écriture du tuyau à l'extrémité de lecture du tuyau. Les tuyaux sont souvent utilisés pour transmettre la sortie d'une application directement à une autre en tant qu'entrée ; les interprètes de ligne de commande Unix, MS-DOS et OS/2 peuvent connecter de longues chaînes d'applications via des tuyaux afin d'accomplir des tâches complexes.
Les files d'attente permettent à des blocs de données plus importants, généralement des enregistrements de plus d'un caractère, d'être transmis entre les applications dans l'ordre. Les files d'attente sont souvent utilisées pour implémenter d'autres mécanismes de communication interprocessus, tels que les messages.
De nombreux environnements multitâches disposent d'installations permettant aux applications d'échanger des messages, c'est-à-dire des blocs de données dont le format est défini par le système ou les applications concernées. Les formats exacts et la sémantique des messages varient considérablement d'un système à l'autre.
Un signal (parfois appelé "interruption logicielle") indique à une tâche d'abandonner ce qu'elle est en train de faire et de traiter immédiatement un événement asynchrone. En général, cela se fait par l'exécution d'un morceau de code spécial appelé, en toute logique, un "gestionnaire de signal". La plupart des environnements multitâches qui implémentent des signaux mettront immédiatement fin à une application si elle reçoit un signal qu'elle n'est pas prête à gérer. Dans le jargon de certains systèmes (comme l'Amiga), le terme "signal" est utilisé pour décrire ce que j'ai défini plus haut comme un sémaphore.
Les "tuyaux nommés" sont similaires aux tuyaux en ce sens qu'ils permettent aux tâches d'échanger des données un caractère à la fois. Cependant, à la différence des tuyaux ordinaires, ils peuvent également gérer la transmission de blocs de données plus importants, être utilisés sur un réseau ou transporter des données dans les deux sens (comme une paire de tuyaux ordinaires). Dans les systèmes qui gèrent des tuyaux nommés, les tuyaux ordinaires sont souvent appelés tuyaux anonymes afin d'établir une distinction claire entre les deux.
La plupart des systèmes multitâches permettent à deux tâches de partager un bloc de mémoire commun, ce qui constitue sans doute la forme la plus rapide de communication interprocessus. Lorsque la mémoire partagée est utilisée, d'autres mécanismes (tels que les sémaphores) sont souvent utiles pour arbitrer l'accès à la zone commune. La mémoire partagée est rarement (voire jamais) disponible pour les processus communiquant sur un réseau, une contrainte qui limite son utilité dans certaines situations.
Les versions d'Unix développées à l'Université de Californie à Berkeley contiennent un mécanisme utile de communication interprocessus appelé "interface de connexion" ("sockets"). Semblables à certains égards à des tuyaux, les interface de connexion permettent à un processus sur un ordinateur en réseau de lancer un programme sur un autre ordinateur, d'alimenter ce programme en données d'entrée et de collecter les données de sortie. Cette fonctionnalité s'est avérée suffisamment utile pour être implémentée dans toutes les versions d'Unix (et peut-être d'autres systèmes d'exploitation) à l'avenir.
Quelques environnements réels
Jusqu'à présent, j'ai couvert la plupart des points nécessaires pour comprendre le fonctionnement interne de nombreux systèmes du monde réel. Quels sont les produits disponibles et quelles sont les capacités de chacun ?
Bien qu'une description complète de n'importe quel système puisse remplir (et remplisse souvent) plusieurs volumes, je vais passer en revue quelques-uns des environnements multitâches les plus populaires pour les ordinateurs personnels et examiner comment ils gèrent certaines des fonctions mentionnées ci-dessus (voir le tableau 1).
Tableau 1 : les environnements multitâches comparés.
** DESQview nécessite l'utilisation de QEMM (Quarterdeck Expanded Memory Manager) ou de CEMM (Compaq Expanded Memory Manager) pour tirer pleinement parti du microprocesseur 80386.
*** Sous MultiFinder, il est possible pour les tâches d'une même machine de communiquer entre elles via AppleTalk. Ce mécanisme peut être utilisé pour passer une adresse à un bloc de mémoire sur le sommet du système, ce qui permet d'autres communications par le biais de la mémoire partagée.
Microsoft Windows 2.0
Microsoft Windows 2.0 offre une interface graphique fenêtrée et des capacités multitâches limitées sur PC et compatibles. L'interface est conforme à la norme SAA (Systems Application Architecture) d'IBM, ce qui signifie qu'elle a la même apparence que le futur OS/2 Presentation Manager.
Les applications écrites spécifiquement pour fonctionner avec Windows s'exécutent dans Windows et participent au multitâche non préemptif. D'autres applications MS-DOS, principalement celles écrites pour être compatibles avec Top View, peuvent être exécutées dans Windows, mais seulement une à la fois. Mais pour les applications DOS qui se comportent mal, Windows 2.0 ne peut servir que de commutateur de programmes. Les applications spécifiques à Windows peuvent communiquer entre elles par le biais d'un système de transmission de messages ; aucun autre moyen de communication interprocessus n'est prévu. Les programmes TSR ne peuvent pas être exécutés dans une fenêtre, mais un certain nombre "d'applications de bureau" sont fournies, dont les traditionnels calendrier, calculatrice, bloc-notes et horloge, ainsi que de simples programmes de dessin.
Windows utilise le passage de messages pour implémenter un protocole de haut niveau unique appelé "Dynamic Data Exchange" (DDE). Grâce à ce protocole, les applications peuvent s'envoyer des données à la volée, de sorte qu'une feuille de calcul, par exemple, peut être continuellement mise à jour avec les informations qui entrent dans le système par le biais d'un programme de communication.
Microsoft Windows 2.0 utilise un certain nombre de méthodes uniques pour gérer le stockage. Les applications peuvent partager le code des bibliothèques de liens dynamiques : des routines liées automatiquement à l'application lors de son chargement. Des parties d'applications Windows aussi petites qu'une procédure ou une fonction unique peuvent être marquées comme "jetables" et échangées en fonction des besoins. En outre, les applications MS-DOS conventionnelles peuvent être transférées vers et depuis le disque.
Microsoft Windows/386
Microsoft Windows/386 offre la même interface utilisateur que Windows 2.0, mais il utilise le mode 8086 virtuel du processeur 80386 pour permettre à n'importe quelle application MS-DOS de s'exécuter dans une fenêtre en même temps que d'autres programmes. Le multitâche est préemptif. Tous les programmes peuvent également s'exécuter en arrière-plan sans intervention de l'utilisateur.
L'architecture 80386 assure la protection de la mémoire ; une application qui tombe en panne ne peut pas planter toute la machine. Comme dans Windows 2.0, la communication interprocessus se fait par transmission de messages.
DESQview
DESQview, de Quarterdeck Office Systems de Santa Monica, Californie, est présenté comme un intégrateur multi-fenêtres. Conçu pour fonctionner sur tous les membres de la famille IBM PC et compatibles, les capacités de DESQview varient en fonction des caractéristiques du matériel spécifique utilisé.
Lorsqu'il fonctionne sur un système non-80386, DESQview fait plus d'efforts que Windows 2.0 pour faire fonctionner de nombreux programmes mal élevés dans des fenêtres. En utilisant des chargeurs pour appliquer des correctifs spéciaux à des programmes tels que Lotus 1-2-3, il obtient la possibilité de les faire fonctionner sous Windows. Comme avec Windows 2.0, n'importe quel programme MS-DOS peut être exécuté si on lui donne le plein écran et le contrôle total du processeur.
Sur un système 80386, DESQview peut s'associer à un autre programme de Quarterdeck, QEMM (Quarterdeck Expanded Memory Manager) pour exécuter chaque programme dans une machine virtuelle. Comme pour Windows/386, cela permet à n'importe quelle application de s'exécuter dans une fenêtre.
Le multitâche dans DESQview est préemptif, la tâche s'exécutant dans la fenêtre la plus en avant (la tâche de premier plan) étant prioritaire. L'API (interface de programme d'application) de DESQview fournit des fonctions de communication interprocessus, notamment des files d'attente, le passage de messages et des signaux.
DESQview peut utiliser la mémoire étendue ou "Expanded Memory Specification" (EMS) pour se stocker et stocker vos programmes d'application, mais il fonctionne mieux lorsque la plus grande partie possible de la mémoire est EEMS (EMS amélioré, également connu sous le nom de LIM 4.0). Toutefois, si vous manquez de mémoire vive, vous pouvez désactiver une application et la transférer sur le disque. Certaines applications, telles que les programmes de communication, ne peuvent pas être retirées du disque de cette manière.
OS/2
OS/2, développé conjointement par Microsoft et IBM, est un système d'exploitation multitâche conçu spécifiquement pour les machines de classe 80286. Il offre un multitâche préemptif et une vaste gamme de services d'application, ainsi que la possibilité d'exécuter une seule application MS-DOS dans un environnement spécial connu sous le nom de "Compatibility Box" (boîte de compatibilité). Lorsqu'il est complété par le gestionnaire de présentation OS/2 (qui sera disponible au cours du second semestre de 1988), OS/2 offre une interface utilisateur et des capacités multitâches semblables à celles de Windows/386, ainsi que de puissantes possibilités de mise en réseau, le tout sur une machine standard 80286 telle que l'IBM PC AT.
L'ordonnancement sous OS/2 s'effectue selon un schéma complexe et stratifié. Chaque fil d'exécution, ou tâche, peut être classé dans l'une des trois catégories suivantes : critique, générale ou de faible priorité. Dans la catégorie de priorité générale, il existe des sous-niveaux supplémentaires, dont les plus élevés sont attribués aux tâches interactives et dans l'une des fenêtres les plus en vue (premier plan). En outre, il existe des mécanismes permettant d'éviter la "privation" et d'augmenter le débit perçu du système.
OS/2 implémente un vaste assortiment de mécanismes de communication interprocessus (IPC), y compris les sémaphores, les tuyaux, les files d'attente, les tuyaux nommés, la mémoire partagée, les signaux, les messages et DDE (comme dans Windows). À l'exception peut-être d'Unix, aucun système d'exploitation n'intègre autant de mécanismes IPC qu'OS/2.
OS/2 implémente le surengagement de stockage pour toutes les applications selon les besoins (sauf dans la boîte de compatibilité).
Parce qu'il fonctionne en mode protégé, OS/2 peut souvent attraper les applications erronées avant qu'elles ne fassent planter la machine. Malheureusement, parce que la boîte de compatibilité ne fonctionne pas en mode protégé, une application DOS qui se comporte mal peut bloquer tout le système.
Unix
Unix, le grand-père des systèmes multitâches modernes, est le seul environnement de ce groupe à avoir été conçu pour être multi-utilisateurs. Pratiquement toutes les implémentations d'Unix peuvent accepter des utilisateurs sur des terminaux ainsi que sur la console principale.
Unix et ses équivalents sont disponibles pour de nombreuses variétés de machines. Le système A/UX d'Apple implémente Unix sur le Macintosh, tandis que Microport et Phoenix Technologies (entre autres) sont les principaux fournisseurs d'Unix pour les compatibles IBM PC AT.
Unix établit un ordonnancement en mesurant la durée d'exécution de chaque processus du système avant qu'il ne s'arrête pour effectuer des entrées/sorties. Toute tâche qui s'exécute pendant toute la durée de l'exécution est considérée comme une tâche d'exécution. Toute tâche qui s'exécute pendant une tranche de temps complète sans effectuer d'entrée ou de sortie est considérée comme monopolisant l'unité centrale et se voit attribuer une priorité moindre. À l'inverse, une tâche qui effectue un grand nombre d'entrées/sorties bénéficie d'une priorité plus élevée, non seulement parce qu'elle n'a pas utilisé une grande partie de chaque tranche de temps, mais aussi parce que la perception des performances s'améliore si le clavier, l'écran et le disque semblent répondre rapidement.
Les IPC varient d'une version à l'autre d'Unix. Toutefois, les plus couramment utilisées sont les sémaphores (implémentées par le système de fichiers), les tuyaux et les signaux. La mémoire partagée, les interfaces de connexion, les tuyaux nommés et des fonctions plus ésotériques telles que les flux et les appels de procédure à distance (utilisés sur les réseaux) sont également disponibles dans de nombreuses implémentations.
Amiga Exec/AmigaDOS
Le multitâche sur Amiga est géré par Exec, un noyau multitâche de haute performance. Avec AmigaDOS et le reste du noyau en ROM de l'Amiga, Exec gère les tâches sur une base de priorité stricte. Le système de fenêtrage de l'Amiga, Intuition, fournit des facilités d'interface utilisateur.
Les communications interprocessus sur Amiga sont basées sur trois mécanismes : les signaux (qui sont en fait des sémaphores), le passage de messages et les interruptions logicielles (similaires à ce que j'ai appelé "signaux" plus haut). En raison de la nature "légère et mesurée" du logiciel système de l'Amiga, les communications interprocessus doivent être effectuées avec précaution ; l'envoi d'un signal ou d'un message à une tâche inexistante fera planter la machine. Cependant, si elle est utilisée correctement, la vitesse des communications interprocessus sur Amiga approche les limites théoriques du microprocesseur 68000.
MultiFinder
MultiFinder fonctionne sur l'ensemble de la gamme d'ordinateurs Apple Macintosh et réalise un multitâche non préemptif sur les applications Macintosh. En capturant les appels système et en gérant soigneusement la mémoire, MultiFinder peut permettre à 30 applications de s'exécuter simultanément dans des fenêtres sur l'écran du Macintosh. L'application qui possède la fenêtre la plus en avant a la priorité la plus élevée. Chaque tâche renonce au contrôle lorsqu'elle appelle SystemTask ou GetNextEvent. Selon les règles de programmation du Macintosh, les tâches doivent appeler ces fonctions au moins 60 fois par seconde. Les changements de tâches ne peuvent pas se produire pendant les opérations sur les fichiers.
MultiFinder n'autorise que deux IPC : le réseau AppleTalk (qui permet les communications intramachine et intermachine) et la mémoire partagée. La mémoire partagée doit être gérée avec soin afin de ne pas corrompre l'espace dédié au système. MultiFinder n'offre aucune protection de la mémoire, puisque seul le Mac II possède une MMU.
Choisissez votre environnement
Le monde de la micro-informatique a considérablement évolué ces dernières années, tant au niveau du matériel que des logiciels. Ce n'est plus seulement la performance du matériel qui fait vendre un micro-ordinateur : les performances du système d'exploitation de l'ordinateur font l'objet d'un examen approfondi. Le logiciel peut-il améliorer votre productivité en vous permettant de passer rapidement d'un programme à l'autre en même temps ? Pouvez-vous télécharger un long rapport du bureau tout en travaillant à la maison sur votre traitement de texte ?
Les fournisseurs prévoient d'avancer lentement afin que les utilisateurs puissent s'adapter aux capacités des nouveaux systèmes d'exploitation et éliminer progressivement les logiciels qui ne se comportent pas correctement. OS/2 de Microsoft offre l'interface DOS familière tout en permettant l'accès aux fonctions multitâches. Apple prévoit de mettre à jour MultiFinder et de publier des améliorations tous les six mois.
Néanmoins, le multitâche sur micro-ordinateur n'en est qu'à ses débuts. Tout le monde n'en a pas besoin : vous pouvez vous contenter de fonctionner en mode mono-utilisateur, en exploitant chaque iota de performance de votre micro-ordinateur sans encourir la pénalité de surcharge requise par le multitâche. Si vous avez besoin des capacités offertes par le multitâche, quelle que soit la machine que vous utilisez, comme vous pouvez le constater, vous avez le choix.
|
