Vous appuyez sur le bouton d’alimentation. L’écran s’allume. Vous cliquez sur une icône. C’est comme si vous étiez le chef d’orchestre d’un orchestre, agitant votre souris pour appeler Spotify ou Chrome. Mais ce sentiment de contrôle total est une illusion.
Il y a un travailleur silencieux derrière la vitre. Il gère la logique désordonnée et complexe pour que vous n’ayez pas à le faire. Ce travailleur est le système d’exploitation.
Sans cela, votre matériel n’est qu’un presse-papier coûteux. Le système d’exploitation est le gestionnaire. Il décide quel programme utilisera le CPU. Il achemine les données vers l’imprimante. Cela empêche la mémoire de planter lorsque vous ouvrez trop d’onglets.
Les grands acteurs sur les ordinateurs de bureau
Microsoft Windows domine toujours le marché des ordinateurs personnels. C’est la valeur par défaut pour la plupart des plates-formes de travail de bureau et de jeu. Les utilisateurs Apple vivent sous macOS, qui est étroitement intégré au matériel.
Ensuite, il y a Linux. Vous le connaissez comme le moteur d’Internet. Il gère la plupart des serveurs qui maintiennent les sites Web en ligne. Mais Linux n’est plus réservé aux administrateurs système. Les distributions comme Ubuntu ou Fedora sont devenues étonnamment conviviales pour les utilisateurs quotidiens qui souhaitent éviter l’écosystème Microsoft.
Écosystèmes mobiles et embarqués
Le paysage des smartphones est un duopole. Android de Google détient la majorité mondiale. L’iOS d’Apple détient le marché haut de gamme dans des pays comme les États-Unis.
Certains constructeurs tentent de se démarquer. Huawei utilise son propre HarmonyOS. Samsung a fortement poussé One UI. Mais la plupart des skins Android restent ancrés dans le même noyau sous-jacent.
Apple ne s’arrête pas seulement aux téléphones. L’iPad exécute iPadOS. L’Apple Watch exécute watchOS. Le boîtier TV exécute tvOS. Chacune est une variation sur le même thème : contrôle strict, haute sécurité et intégration matérielle approfondie.
Au-delà de l’écran
On oublie souvent que tout a désormais un cerveau. Votre réfrigérateur intelligent en possède un. Votre téléviseur en possède un. Le système d’infodivertissement de votre voiture exécute un système d’exploitation personnalisé, souvent basé sur QNX ou Android Automotive.
Les voitures autonomes sont une tout autre bête. Leurs systèmes d’exploitation doivent traiter les données des capteurs en millisecondes. Un décalage n’est pas seulement une gêne. C’est un handicap.
Qu’est-ce qui en fait réellement un système d’exploitation ?
Tous les logiciels ne sont pas des systèmes d’exploitation. Un traitement de texte n’est pas un système d’exploitation. Un navigateur Web n’est pas un système d’exploitation.
Pour gagner le titre, le logiciel doit faire trois choses :
- Gérer le matériel : Il communique directement avec le processeur, la mémoire et le stockage.
- Fournir une interface utilisateur : Elle vous permet d’interagir, que ce soit via une souris ou un écran tactile.
- Exécuter des applications : Il fournit l’environnement dans lequel d’autres logiciels vivent et s’exécutent.
“Un système d’exploitation est le pont entre votre intention et les capacités de la machine.”
Sans ce pont, vous ne pouvez pas exécuter d’applications. Vous ne pouvez pas enregistrer de fichiers. Vous ne pouvez pas vous connecter au Wi-Fi. Vous êtes coincé.
Pourquoi cela est important pour vous
Comprendre votre système d’exploitation est important car il dicte votre sécurité, votre confidentialité et votre flexibilité. Les mises à jour Windows peuvent forcer les redémarrages. macOS vous verrouille dans les services Apple. Linux offre de la liberté mais exige de la maintenance.
Dans les sections suivantes, nous expliquerons exactement le fonctionnement de ces systèmes. Nous allons regarder le noyau. Nous discuterons de l’interface utilisateur. Et nous vous montrerons comment reprendre une partie de ce contrôle que vous pensez avoir.
Pourquoi la plupart des Gadons ignorent le système d’exploitation
Vous pourriez supposer que chaque code exécutant une puce nécessite un système d’exploitation à part entière. Ce n’est pas le cas. Emportez l’ordinateur dans votre micro-ondes. Cela fait un travail. Il réchauffe les aliments. L’entrée est un clavier. Le matériel ne change jamais.
Un système d’exploitation élaboré n’est ici qu’un bagage. Cela fait grimper les coûts. Cela ajoute de la complexité là où aucune n’est nécessaire. Au lieu de cela, ces appareils exécutent un seul programme câblé. Il s’agit d’un système embarqué. Il fonctionne constamment. Il ne démarre pas. Il ne se met pas à jour. Cela fonctionne.
Mais pour les autres appareils, les règles changent.
La valeur d’un système d’exploitation
Pourquoi nous embêtons-nous avec les systèmes d’exploitation ? Parce qu’ils permettent de la flexibilité. Sans cela, vous êtes coincé avec ce que le fabricant du matériel a décidé que vous devriez faire. Un système d’exploitation crée la possibilité de :
- Servir à diverses fins sur le même matériel
- Interagir avec les utilisateurs de manière compliquée
- S’adapter aux besoins qui évoluent avec le temps
C’est pourquoi chaque ordinateur de bureau en est livré avec un. Vous avez la famille Windows de Microsoft. Vous disposez d’un macOS d’Apple. Ensuite, il y a la famille UNIX, une mosaïque d’individus et d’entreprises au fil des décennies. Au-delà de ceux-ci, des centaines d’autres systèmes existent. Ils sont spécialisés dans les mainframes. Robotique. Fabrication. Contrôle en temps réel.
La puissance du code portable
Voici la principale différence entre un micro-ondes et votre ordinateur portable. On peut être modifié. L’autre ne le peut pas.
Les systèmes d’exploitation utilisent du code portable plutôt que des circuits physiques permanents. Ce n’est pas un heureux accident. C’est un choix de conception. Il permet des modifications sans mettre l’appareil au rebut.
Pour un utilisateur d’ordinateur de bureau, cela signifie la survie. Vous recevez une mise à jour de sécurité. Vous installez un correctif. Vous ajoutez une nouvelle application. Si le système d’exploitation devient trop volumineux ou incompatible, vous pouvez en installer un complètement nouveau. Vous ne jetez pas l’ordinateur à la poubelle. Vous ne recommencez pas avec un nouveau matériel. Tant que vous savez comment accéder au système, vous pouvez modifier son comportement.
Que fait réellement un système d’exploitation ?
Supprimez l’interface utilisateur. Supprimez les icônes. Que reste-t-il ?
Dans sa forme la plus simple, un système d’exploitation remplit deux fonctions essentielles.
Premièrement, il gère les ressources. Cela s’applique aux ordinateurs, tablettes et smartphones. Il gère le processeur. Il alloue de la mémoire. Il gère l’espace disque. Il jongle avec tout.
Deuxièmement, il fournit une interface stable. Il donne aux applications un moyen cohérent de communiquer avec le matériel. L’application n’a pas besoin de connaître la tension du processeur. Il n’est pas nécessaire de connaître la cartographie sectorielle du disque dur. Le système d’exploitation résume les détails. Il permet au logiciel de fonctionner sans connaître les secrets de la machine.
Cette abstraction est la raison pour laquelle votre logiciel fonctionne sur différentes machines. C’est pourquoi vous n’avez pas besoin d’écrire un nouveau pilote à chaque fois qu’une nouvelle carte graphique sort. Le système d’exploitation gère la traduction.
Considérez l’unité centrale de traitement (CPU) comme une cuisine bondée pendant les heures de pointe du dîner. Plusieurs programmes réclament votre attention. Certains ont besoin de plus de mémoire. D’autres nécessitent une bande passante d’E/S importante. Sans ordre, c’est le chaos. Le système d’exploitation intervient. Il agit comme un parent strict mais juste. Son travail ? Allouer des ressources pour qu’aucune application ne fasse planter la fête. Il gère une capacité limitée pour le plus grand bien de chaque utilisateur et application exécutés simultanément.
Pourquoi la cohérence est importante
La deuxième responsabilité majeure consiste à fournir une interface utilisateur cohérente. Cela devient critique lorsque vous déployez plusieurs ordinateurs du même type. Ou si vous échangez des composants matériels. Une interface de programmation d’applications (API) standardisée est la sauce secrète.
Les développeurs s’appuient sur cette cohérence. Ils écrivent du code une fois. Ils le déploient sur différentes machines. Ils le font avec la certitude que le logiciel fonctionnera toujours. Même si la machine cible dispose de différentes quantités de RAM ou d’espace de stockage. L’API résume les différences matérielles. Le développeur n’a pas besoin de réécrire la logique de base pour chaque configuration spécifique.
Gérer la diversité matérielle
Même sur une machine unique et personnalisée, le système d’exploitation maintient la stabilité pendant les mises à niveau. Cela se produit parce que c’est le système d’exploitation, et non l’application, qui contrôle le matériel. L’application demande simplement des services. Le système d’exploitation les livre.
Cela crée un énorme défi pour les développeurs. Ils doivent conserver leurs systèmes d’exploitation suffisamment flexibles pour prendre en charge des milliers de fournisseurs. Vous entrez dans un magasin aujourd’hui. Vous pouvez construire un PC avec une imprimante de marque A, un lecteur de disque de marque B et un périphérique spécialisé de marque C. Le système d’exploitation doit gérer n’importe quelle combinaison. Cela fait abstraction de la complexité. Il garantit que votre logiciel fonctionne quel que soit le silicium sous-jacent.
Types de systèmes d’exploitation
La plupart des gens cliquent simplement sur une souris et s’attendent à ce que l’écran fasse ce qu’ils veulent. Mais derrière ce curseur se cache une hiérarchie complexe de types de logiciels. Ils ne sont pas tous construits de la même manière. La catégorie dépend de ce que l’ordinateur contrôle et des applications qu’il exécute.
Les systèmes durs en temps réel
Les systèmes d’exploitation en temps réel (RTOS) ne se soucient pas du fond d’écran de votre bureau. Ils contrôlent les machines. Instruments scientifiques. Automatisation industrielle.
Un RTOS est une boîte scellée. Il n’a pas d’interface utilisateur. Aucun utilitaire pour l’utilisateur final. Juste une pure fonction. Le but est la précision. Une opération spécifique doit prendre exactement le même temps à chaque exécution.
Pourquoi est-ce important ? Imaginez une machine complexe. Si un bras robotique se déplace plus rapidement que prévu simplement parce que le système est inactif, il risque de heurter quelque chose. Catastrophique. Si elle avance plus lentement parce que le système est occupé, la chaîne de production s’arrête. Les deux résultats sont des échecs. La cohérence est la seule mesure.
Faire une chose à la fois
Les systèmes à utilisateur unique et à tâche unique sont, à certains égards, des reliques, mais ils existent. Ils laissent une seule personne faire une chose. Période.
MS-DOS est l’exemple classique. Vous ouvrez un programme. Vous travaillez. Vous ne pouvez pas exécuter un téléchargement en arrière-plan lors de la modification du texte. C’est linéaire. Simple. Très simple.
La norme moderne : le multitâche avec un seul utilisateur
C’est ce que vous utilisez probablement en ce moment. C’est la norme pour les ordinateurs de bureau et portables. Microsoft Windows. Apple macOS.
Ils vous laissent jongler. Vous pouvez rédiger un document tout en téléchargeant un fichier et en imprimant un e-mail. Le système d’exploitation bascule entre ces tâches si rapidement qu’il semble simultané. Ce n’est pas le cas. C’est vraiment très bon pour changer de contexte.
Partager la charge : systèmes multi-utilisateurs
Les systèmes d’exploitation multi-utilisateurs permettent à de nombreuses personnes d’accéder aux ressources en même temps. Mais ce n’est pas pour autant.
Le système doit équilibrer les exigences. Chaque utilisateur obtient des ressources distinctes. Si l’application de l’utilisateur A plante, l’utilisateur B ne devrait pas le remarquer. Unix. VMS. Systèmes mainframe comme MVS. Ce sont les poids lourds des environnements d’entreprise où la stabilité au sein d’une communauté d’utilisateurs n’est pas négociable.
Informatique distribuée
Les systèmes d’exploitation distribués ne gèrent pas qu’une seule machine. Ils en gèrent un réseau.
Au lieu qu’un superordinateur résolve un gros problème, le système d’exploitation le résout. Les pièces vont à de nombreux ordinateurs plus petits. Vous voyez cela dans les fermes de serveurs géantes. Mais cela ne concerne pas uniquement les entreprises. Les amateurs et les éducateurs construisent leurs propres systèmes distribués à l’aide de machines bon marché. Parfois même des consoles de jeux réutilisées.
C’est un moyen de mutualiser l’énergie sans acheter de superordinateur.
Ne confondez pas réseau et multi-utilisateur
C’est ici que les choses se compliquent. Un système multi-utilisateur n’est pas la même chose qu’un système mono-utilisateur sur un réseau.
Travailler pour une entreprise ? Vous êtes probablement sur un système mono-utilisateur. L’administrateur contrôle ce que vous pouvez installer. Vous pouvez imprimer sur une imprimante partagée. Vous pouvez accéder à un serveur de fichiers pour les documents du service.
C’est ça le réseautage. Pas multi-utilisateur. Le système d’exploitation lui-même n’accorde pas de droits d’accès simultanés à différents utilisateurs sur cette machine locale spécifique. Il parle simplement à d’autres machines.
Le processus de démarrage : comment le système d’exploitation prend le contrôle
Lorsque vous actionnez le commutateur, le système d’exploitation ne s’exécute pas immédiatement. Le firmware le fait en premier.
Sur les PC plus anciens, il s’agissait du BIOS. Les machines plus récentes utilisent UEFI (Unified Extensible Firmware Interface). Ce code vérifie le matériel. Est-ce que tout fonctionne ? Sur UEFI, il vérifie également si le logiciel de démarrage est légitime. Démarrage sécurisé. Aucune falsification.
Une fois les tests réussis, le micrologiciel est transféré au chargeur d’amorçage.
Le chargeur Bootstrap
Le chargeur de démarrage a une tâche. Chargez le système d’exploitation en mémoire. Démarrez-le.
C’est un petit programme. Brutalement simple. Il configure des programmes pilotes pour les sous-systèmes matériels. Cela divise la mémoire. Certaines pièces contiennent le système d’exploitation. Certains contiennent des informations sur les utilisateurs. Certains détiennent des candidatures.
Il construit des structures de données. Signaux. Drapeaux. Sémaphores. Ce sont les lignes de communication entre les sous-systèmes et les applications.
Ensuite, il remet les clés au système d’exploitation. Le contrôle change de mains.
Ce que fait réellement le système d’exploitation
Une fois chargé, le système d’exploitation gère les fonctions de base. Ils tombent dans des seaux :
- Gestion des processeurs
- Gestion de la mémoire
- Gestion des appareils
- Gestion du stockage
-Interface des applications
-Interface utilisateur - Gestion de la sécurité du système
Ce sont les piliers. Chaque système d’exploitation, de votre téléphone à un superordinateur, touche ces sept domaines. Les outils qu’ils utilisent pour exécuter ces fonctions varient énormément, mais les objectifs restent les mêmes. Gardez le matériel en vie. Gardez le logiciel en marche. Empêchez l’utilisateur de tout planter.
La puissance de traitement est une ressource limitée. Si vous souhaitez que votre ordinateur gère un appel vidéo tout en téléchargeant un fichier volumineux et en exécutant une analyse antivirus, le processeur doit diviser son temps. Ce n’est pas magique. C’est des mathématiques. Et tout cela est géré selon une hiérarchie stricte.
Le système d’exploitation ne regarde pas seulement votre application ouverte. Il examine les processus. Un processus est tout logiciel effectuant une action. Vous pourriez considérer votre navigateur Web comme une entité unique. Ce n’est pas le cas. C’est un processus, oui, mais il génère d’autres processus pour gérer les requêtes réseau, l’allocation de mémoire et le rendu. Il existe également des dizaines de processus invisibles exécutés en arrière-plan, gérant les E/S de disque ou recherchant la présence de logiciels malveillants. Le système d’exploitation planifie ces processus, pas les applications que vous voyez à l’écran.
Au sein d’un processus, le vrai travail se déroule dans les threads. Une application doit avoir au moins un processus, et ce processus doit avoir au moins un thread. Le planificateur gère les threads jusqu’à la plus petite unité d’exécution. Cette distinction est importante car la commutation de threads est plus rapide et moins gourmande en ressources que la commutation de processus. Lorsque vous effectuez plusieurs tâches à la fois, vous ne changez pas simplement de fenêtre. Vous changez de contexte CPU entre des threads appartenant à différents processus.
Le rôle des interruptions dans le contrôle du processeur
Le flux fluide du code est constamment interrompu par la réalité. Les interruptions sont des signaux envoyés par le matériel ou le logiciel pour exiger l’attention du processeur. Imaginez une réunion où quelqu’un lève soudainement la main. Le processeur met en pause tout ce qu’il fait pour résoudre l’interruption.
Toutes les interruptions ne sont pas créées égales. Le système d’exploitation peut parfois masquer les interruptions. Cela signifie qu’il ignore temporairement les signaux provenant de sources moins critiques pour terminer une tâche spécifique sans interruption. Mais certaines interruptions ne peuvent être ignorées. Il s’agit d’interruptions non masquables (NMI). Ils exigent une action immédiate, quelle que soit ce que fait le processeur.
Pourquoi est-ce important pour vous ? Pensez à la batterie de votre ordinateur portable. Si la puissance chute à un niveau critique, un NMI se déclenche. Il n’attend pas que votre traitement de texte enregistre. Il force immédiatement une séquence d’arrêt ou d’hibernation. L’ignorer entraînerait une perte de données ou des dommages matériels. Le système d’exploitation donne la priorité à l’intégrité du système plutôt qu’au flux des applications lorsque des NMI se produisent.
L’illusion du multitâche
Dans un système monotâche, le planning est simple. L’application s’exécute jusqu’à ce qu’elle rencontre une interruption ou une entrée utilisateur. Mais les systèmes modernes sont multitâches. Le système d’exploitation doit donner l’impression que tout se passe en même temps. Même avec les processeurs multicœurs, chaque cœur ne gère qu’une seule tâche à la fois. L’illusion de simultanéité est créée par la vitesse.
Le système d’exploitation bascule entre les processus des milliers de fois par seconde. C’est assez rapide pour que vous ne remarquiez pas les écarts. Mais la mécanique est précise. Voici ce qui se passe lors de ce changement :
- Un processus contient des ressources spécifiques dans la RAM, les registres, les piles et les files d’attente.
- Le système d’exploitation attribue un nombre défini de cycles CPU au premier processus.
- Lorsque ces cycles expirent, le système d’exploitation met le processus en pause.
- Il enregistre l’état du premier processus : copie de tous les registres, piles et files d’attente en mémoire. Il note également le pointeur d’instruction exact à l’endroit où le processus s’est arrêté.
- Il charge l’état du processus suivant : restauration de ses registres et files d’attente depuis la mémoire.
- Le deuxième processus arrive à son tour.
C’est ce qu’on appelle le changement de contexte. C’est efficace, mais ce n’est pas gratuit. La copie de la mémoire et la mise à jour des registres prennent des cycles. Si vous exécutez une tâche gourmande en CPU, des changements de contexte fréquents peuvent entraîner une latence. Le système d’exploitation tente de minimiser cela en regroupant les threads associés ou en accordant des tranches de temps plus longues aux processus hautement prioritaires.
Pourquoi le nombre de cœurs ne résout pas tout
Vous pourriez acheter un processeur à 16 cœurs et supposer que vos problèmes sont résolus. Ce n’est pas le cas. Chaque cœur est toujours un exécuteur monothread en son cœur. Si votre logiciel est mal optimisé, il n’utilisera pas tous ces cœurs. Il restera sur un noyau tandis que les autres resteront inactifs.
C’est pourquoi l’optimisation des logiciels est importante. Les développeurs doivent concevoir des applications pour générer plusieurs threads pouvant être planifiés indépendamment. Si une application est monothread, elle utilisera au maximum un cœur et laissera le reste de votre matériel coûteux ne rien faire. Le système d’exploitation peut planifier l’exécution d’autres processus sur ces cœurs inactifs, mais il ne peut pas diviser une application monothread entre eux.
La relation entre le matériel et les logiciels est une négociation constante. Le CPU fournit des cycles. Le système d’exploitation les divise. Le logiciel les consomme. Lorsqu’une couche ne parvient pas à communiquer clairement, les performances en pâtissent. Vous le ressentez comme un décalage. Le système le ressent comme une inefficacité.
Il y a toujours une limite. Quel que soit le nombre de cœurs que vous ajoutez, le fait de changer de contexte entraîne une surcharge. Plus vous changez rapidement, plus vous passez de cycles à changer plutôt qu’à calculer. C’est un compromis. Un léger retard pour l’apparition de la concurrence. C’est le prix de l’informatique moderne.
Lorsque le système d’exploitation passe d’une tâche à l’autre, il ne se contente pas de deviner ce qui se passe. Il s’appuie sur une structure de données spécifique appelée bloc de contrôle de processus. Considérez cela comme la carte d’identité du processus et le CV actuel combinés. Le système d’exploitation a besoin de chaque détail pour suspendre une tâche et en reprendre une autre sans perdre sa place.
Chaque bloc contient un identifiant unique. Il indique l’endroit où le processus s’est arrêté pour la dernière fois dans le code et les données. Il capture l’état exact des registres et des drapeaux. Il répertorie les fichiers ouverts. Il suit les limites de la mémoire et l’état des E/S. Et cela définit la priorité.
Sans ces détails, le système d’exploitation serait aveugle lors du changement de contexte.
Un processus n’est pas toujours actif. Parfois, c’est suspendu. Peut-être qu’il attend une frappe. Pendant qu’il attend, il ne consomme aucun cycle CPU. Il reste inactif. Lorsque l’entrée arrive, le statut change. Le système le fait passer de l’état d’attente à l’état d’exécution. Le bloc de contrôle du processus devient alors la directive. Il indique au mécanisme de commutation exactement comment reprendre l’exécution.
Cela se produit silencieusement. Vous ne voyez pas l’échange. Vous voyez juste des transitions douces. Chaque processus dispose de suffisamment de temps CPU pour faire son travail. Mais il y a une limite. Si vous ouvrez trop d’applications, le système d’exploitation a du mal. Il utilise plus de cycles pour sauvegarder et restaurer les registres. Les files d’attente s’allongent. Les piles deviennent plus profondes.
Finalement, le système passe plus de temps à changer qu’à travailler. C’est une raclée. C’est l’équivalent numérique de la surcharge mentale. L’ordinateur essaie d’en faire trop à la fois. Ça étouffe. Il faut généralement intervenir. Fermez les applications. Redémarrage. Ramenez l’ordre dans le chaos.
Les développeurs essaient de concevoir autour de cela. Ils construisent des garde-fous. Mais vous pouvez aider. Ajoutez de la RAM. Fermez les onglets. Laissez le système d’exploitation gérer efficacement les ressources.
Jusqu’à présent, nous avons examiné la planification sur un seul processeur. La plupart des machines modernes ont plusieurs cœurs. Le système d’exploitation doit répartir le travail entre eux. Il équilibre la demande par rapport aux cycles disponibles.
Les systèmes d’exploitation asymétriques réservent un processeur au système d’exploitation lui-même. Les processus de candidature reçoivent le reste. Le système d’exploitation gère son propre entretien séparément.
Les systèmes d’exploitation symétriques répartissent le travail différemment. Ils équilibrent la demande et la disponibilité sur tous les processeurs. Même si seul le système d’exploitation est en cours d’exécution, la charge est partagée. La mémoire est également partagée. Cela s’applique également aux puces multicœurs.
Vous utilisez peut-être actuellement un système symétrique. C’est courant dans les environnements modernes.
Si le système d’exploitation est le seul élément nécessitant du temps d’exécution, le processeur n’est pas le seul goulot d’étranglement. La gestion de la mémoire devient la prochaine priorité.
Stockage et gestion de la mémoire
Les systèmes d’exploitation sont essentiellement des agents de la circulation pour la mémoire de votre ordinateur. Ils ont deux tâches principales. Premièrement, ils garantissent que chaque processus dispose de suffisamment d’espace pour s’exécuter sans marcher sur les pieds d’une autre application. Deuxièmement, ils gèrent les différents types de matériel de mémoire pour que les choses avancent aussi vite que possible.
Le premier travail concerne les limites. Le système d’exploitation crée des barrières strictes entre les types de logiciels et les applications individuelles.
Prenons un exemple simple. Imaginez un petit système avec seulement 1 Mo de RAM. Lors du démarrage, le système d’exploitation réclame 300 kilo-octets pour lui-même. Ensuite, il récupère 200 kilo-octets au fond du pool pour les pilotes matériels. Cela laisse exactement 500 kilo-octets pour vos applications réelles.
Lorsque vous lancez des programmes, le système d’exploitation leur attribue des morceaux de cet espace restant. Si vous ouvrez une nouvelle application pendant que d’autres sont en cours d’exécution, le système peut limiter les fenêtres ouvertes pour libérer des ressources. Mais que se passe-t-il lorsque cet espace de 500 kilo-octets est complètement plein ?
Vous pourriez acheter plus de RAM. La plupart des PC modernes vous permettent de passer de 8 à 16 Go ou plus. Mais même avec d’énormes quantités de mémoire, un processeur ne peut accéder qu’à un seul emplacement à la fois. La majeure partie de votre RAM reste inactive pendant que le processeur traite les données actives.
C’est là qu’intervient la gestion de la mémoire virtuelle.
Le système d’exploitation échange constamment les données inutilisées de la RAM et apporte les données dont le processus actuel a besoin. Cela crée l’illusion que chaque processus possède son propre espace privé et étendu. Cela empêche les processus de se corrompre les uns les autres et maintient le système stable même lorsque la mémoire physique est limitée.
Mais le stockage sur disque n’est pas le seul facteur. Le système d’exploitation doit équilibrer les besoins sur trois couches de mémoire distinctes, classées par vitesse.
Comprendre la hiérarchie de la mémoire et l’échange de pages
La vitesse compte. Si le CPU doit attendre, tout ralentit. La hiérarchie ressemble à ceci :
- Cache haute vitesse : Il s’agit d’une mémoire minuscule et incroyablement rapide située juste à côté du processeur. Les contrôleurs de cache prédisent les données dont vous aurez besoin ensuite et les extraient de la mémoire principale avant même que vous les demandiez. Tout est question de prédiction et de vitesse.
- Mémoire principale : Il s’agit de votre RAM standard. Il se mesure en gigaoctets et correspond à ce que vous mettez à niveau lorsque votre ordinateur semble lent.
- Mémoire secondaire : Il s’agit de votre disque dur (HDD) ou de votre disque SSD (SSD). C’est beaucoup plus lent que la RAM mais offre un vaste stockage. Dans la gestion de la mémoire virtuelle, le stockage secondaire agit comme un réservoir de débordement pour la RAM virtuelle.
Le système d’exploitation jongle avec ces couches. Il déplace les données dans des blocs appelés pages entre les types de mémoire disponibles à mesure que les processus demandent plus de ressources. C’est un exercice d’équilibre constant et invisible.
Un processus a besoin de plus de cache ? Le système d’exploitation décale les pages pour s’adapter. Un autre a besoin de plus de RAM physique ? Il échange les pages inactives sur le SSD.
Pourquoi est-ce important pour vous ? Parce qu’il permet à votre ordinateur d’exécuter plusieurs applications lourdes simultanément sans planter. Sans cette gestion, votre système s’arrêterait au moment où la RAM se remplirait. Le système d’exploitation fait tourner les roues en décidant ce qui reste sur la voie rapide et ce qui doit être garé sur la voie lente.
Mais le compromis est toujours la rapidité. Le passage à la mémoire secondaire introduit une latence. C’est pourquoi disposer de plus de RAM physique donne souvent l’impression d’une amélioration directe des performances. Vous réduisez le besoin de ces échanges coûteux.
Le système d’exploitation gère la complexité. Vous obtenez simplement le résultat : un système qui exécute plusieurs applications, les maintient séparées et ne manque pas d’espace.
Le traducteur caché dans votre pile
Les conducteurs sont des intermédiaires méconnus de l’informatique. Vous ne les voyez pas travailler, mais chaque fois que vous appuyez sur une touche ou enregistrez un fichier, ils sont occupés. Le chemin entre le système d’exploitation et presque tout matériel non soudé à la carte mère passe directement par ces programmes. Leur travail est la traduction. Ils prennent le chaos électrique des sous-systèmes matériels et le transforment en un langage de haut niveau que le système d’exploitation et vos applications peuvent réellement comprendre.
Pensez-y. Le système d’exploitation considère les données comme des fichiers. L’imprimante voit des impulsions lumineuses. Le SSD détecte les niveaux de tension dans des cellules de mémoire spécifiques. Les conducteurs comblent cet écart. Ils prennent un fichier défini par le système d’exploitation et le traduisent en flux binaires placés sur le stockage ou en rafales laser destinées au papier. Sans cette couche de traduction, votre ordinateur n’est qu’un tas de métal et de silicium coûteux qui ne sait pas quoi faire de lui-même.
Pourquoi les pilotes vivent en dehors du noyau
Les pilotes sont séparés du système d’exploitation principal pour une raison spécifique : l’agilité. Si chaque nouvelle fonctionnalité nécessitait une modification du noyau, une recompilation et une redistribution de l’intégralité du système d’exploitation, nous ne verrions jamais de mises à jour. Garder les pilotes externes permet aux fabricants d’ajouter des fonctionnalités aux sous-systèmes matériels sans toucher aux fondations.
Cette séparation signifie également que les éditeurs de systèmes d’exploitation n’ont pas besoin d’écrire chaque pilote. Les fabricants de matériel créent ou paient souvent leurs propres pilotes. Cela leur donne un contrôle direct sur la mise à jour et l’amélioration des capacités d’E/S. C’est une division du travail. Le système d’exploitation fournit la scène. Le fabricant du pilote écrit le script.
L’écart entre la communauté et l’entreprise
Il est facile d’attendre des pilotes à jour sous Windows ou macOS. Les grandes entreprises rentables derrière ces systèmes d’exploitation disposent des ressources nécessaires pour assurer la compatibilité. Linux et d’autres systèmes d’exploitation open source empruntent un chemin différent. Ils s’appuient sur des développeurs communautaires. Ces bénévoles donnent de leur temps et de leurs compétences en codage pour fournir des pilotes pour les systèmes et les périphériques. C’est un travail d’amour. Et ça marche, généralement. Mais la cohérence peut varier en fonction de la personne qui gère le code à un moment donné.
Tampons et files d’attente : les contrôleurs de trafic
La gestion des entrées et des sorties ne concerne pas seulement la traduction. Il s’agit de rythmer. Le système d’exploitation gère les E/S via des files d’attente et des tampons. Il s’agit d’installations de stockage spéciales qui captent un flux de bits provenant d’un appareil. C’est peut-être un clavier. C’est peut-être un port série. Le tampon contient ces bits et les libère vers le processeur à une vitesse que celui-ci peut gérer.
Pourquoi est-ce important ? Parce que les processus sont en compétition pour le temps CPU. Le système d’exploitation demande à un tampon de continuer à accepter les entrées d’un périphérique même si le processeur est occupé. Il arrête d’envoyer des données au CPU jusqu’à ce que le processus utilisant cette entrée soit suspendu. Lorsque ce processus se réveille, le tampon libère les données stockées.
Ce mécanisme permet aux appareils à haut débit de fonctionner à leur plein potentiel. Un clavier peut traiter des frappes rapides. Un modem peut gérer de lourdes charges de données. Même lorsque le processeur est débordé et ne peut pas utiliser l’entrée immédiatement, le système ne lâche pas la balle. Les données attendent dans le tampon. C’est un concept simple. Il évite la perte de données lors de scénarios de charge élevée.
La réalité en temps réel
La gestion de toutes ces ressources occupe la majeure partie des fonctions du système d’exploitation. Dans les systèmes d’exploitation en temps réel, il peut s’agir de pratiquement toutes les fonctionnalités requises. Pour les systèmes d’exploitation à usage général, fournir une interface cohérente est l’objectif principal. Les applications et les humains ont besoin d’un moyen simple d’accéder à la puissance matérielle. Le conducteur est la clé qui déverrouille cette porte.
Ce n’est pas parfait. Les conducteurs peuvent planter. Ils peuvent entrer en conflit. Mais ils constituent le lien essentiel entre votre intention et la réponse de la machine. Sans eux, le matériel est sourd et muet. Avec eux, c’est un outil.
La complexité se cache à la vue de tous. Vous cliquez. Le chauffeur traduit. Le matériel agit. La boucle continue.
Les interfaces de programme d’application (API) résolvent un problème spécifique pour les développeurs. Ils suppriment le besoin de comprendre les détails granulaires de la façon dont un processeur traite les instructions. Tout comme les pilotes de périphériques résument la complexité matérielle, les API permettent aux programmeurs d’applications d’appeler les fonctions du système d’exploitation sans suivre chaque état matériel de bas niveau.
Pensez à la création de fichiers. Un scientifique enregistrant les données d’un instrument doit sauvegarder les résultats. Le système d’exploitation fournit une fonction API appelée MakeFile. Le programmeur écrit une commande du type :
MakeFile [1, %Nom, 2]
Cette ligne unique communique une intention complexe. Le chiffre « 1 » spécifie un accès aléatoire. L’alternative « 0 » désignerait un fichier série. %Name extrait le nom de fichier directement de l’entrée de l’utilisateur. Le nombre « 2 » définit le comportement de stockage. Il indique un fichier de taille variable. Zéro signifie une taille fixe. La première signifie que le fichier s’agrandit avec les données mais ne diminue jamais.
Le système d’exploitation gère le reste. Il interroge le lecteur de disque pour connaître le premier emplacement de stockage libre disponible. Ensuite, il met à jour les métadonnées du système de fichiers. Cette entrée suit les blocs de début et de fin, le nom du fichier, le type de fichier et l’état de l’archive. Il enregistre les autorisations des utilisateurs et les horodatages de création.
Cette abstraction est cruciale pour les développeurs. Ils n’ont pas besoin de gérer les codes d’instructions ou les types de données pour chaque disque dur ou lecteur de bande possible. Le système d’exploitation, soutenu par des pilotes matériels, gère ces détails changeants. Le développeur écrit du code pour l’API et fait confiance au système.
Mais cette confiance a un coût. Les API ouvrent des vecteurs d’attaque. Les pirates peuvent exploiter les vulnérabilités des appels API pour obtenir un accès non autorisé. Cela ne veut pas dire que les API sont intrinsèquement mauvaises. Cela signifie que les développeurs doivent corriger les faiblesses de manière agressive. La sécurité n’est pas une fonctionnalité ; c’est une exigence de base.
Les API sont aussi des champs de bataille économiques. Les entreprises se rendent compte que contrôler une API signifie contrôler un segment de l’industrie. Certains développeurs fournissent gratuitement des lecteurs ou des téléspectateurs pour verrouiller les consommateurs. Ils facturent ensuite des redevances aux autres développeurs qui souhaitent que leurs logiciels s’intègrent à ces outils. D’autres publient librement des API pour créer des écosystèmes. La stratégie varie, mais l’objectif est toujours le contrôle du marché.
Interfaces graphiques, shells et environnement de bureau
Si les API standardisent la façon dont les applications communiquent avec le système, l’interface utilisateur (UI) structure la manière dont les humains communiquent avec le système. Au cours de la dernière décennie, le développement a fortement favorisé l’interface utilisateur graphique (GUI). macOS d’Apple et Windows de Microsoft dominent cet espace, capturant la grande majorité des parts de marché.
Linux est différent. La plupart des distributions incluent une interface graphique, mais le choix est décentralisé. L’équipe de distribution sélectionne l’environnement de bureau. Les utilisateurs ne sont pas verrouillés. Ils peuvent changer d’environnement s’ils le souhaitent. Les options populaires incluent Cinnamon, GNOME, KDE et Xfce. Cette flexibilité est une caractéristique de la philosophie Linux.
Ensuite, il y a l’interface de ligne de commande (CLI). Souvent associée à UNIX, cette interface texte uniquement s’appuie sur des commandes saisies. Cela peut sembler intimidant pour les utilisateurs habitués à pointer et à cliquer. Mais il offre une puissance et une flexibilité qui manquent souvent aux interfaces graphiques. Le Korn Shell et le C Shell en sont des exemples classiques. Ils fournissent des utilitaires qui facilitent la manipulation des fonctions du système d’exploitation pour ceux qui connaissent la syntaxe.
Les utilisateurs UNIX ouvrent fréquemment plusieurs fenêtres shell simultanément. Cela permet des flux de travail parallèles qui sont plus difficiles à gérer dans une interface graphique. Cependant, les utilisateurs UNIX et Linux ne sont pas limités à la ligne de commande. Ils peuvent exécuter des interfaces graphiques avec les outils CLI.
Windows, macOS et Linux proposent tous des applications shell ou terminal. Ceux-ci sont destinés aux utilisateurs qui ont besoin d’un accès direct à la ligne de commande.
Il est important de se rappeler où se situent ces interfaces dans la pile. L’interface utilisateur est une couche au-dessus du système d’exploitation. Il s’agit d’un programme ou d’un ensemble de programmes. Les fonctions de gestion de base résident dans le noyau. Le noyau fait le gros du travail. Les liens entre le noyau, l’interface utilisateur et le logiciel utilitaire définissent l’expérience utilisateur. Ces relations déterminent pourquoi macOS est différent de Windows ou pourquoi Linux offre des expériences de bureau si variées. Le noyau reste constant. L’interface change. Et cette distinction continuera à façonner la façon dont nous interagissons avec les ordinateurs dans un avenir prévisible.
La connectivité réseau n’est plus seulement une fonctionnalité. C’est la base. Vous ne pouvez pas vraiment parler d’un système d’exploitation moderne sans reconnaître son bavardage constant avec les serveurs et autres machines. Les développeurs s’appuient sur Internet comme canal principal pour les correctifs, les correctifs de sécurité et les mises à jour principales. Bien sûr, vous pouvez toujours utiliser un DVD ou une clé USB. Mais cela devient une relique. La plupart des systèmes téléchargent tout en arrière-plan pendant que vous dormez.
Il y a cependant une plus grande tension qui se cache sous la surface. C’est une question de philosophie de distribution. Un modèle unique peut-il satisfaire à la fois les géants de l’entreprise et les consommateurs ordinaires ? La réponse est compliquée.
Open Source vs. Source fermée
Linux a changé la donne. Cela a prouvé que les logiciels basés sur les principes open source pouvaient réellement fonctionner à grande échelle. Cela contraste fortement avec le modèle fermé, qui domine l’espace de bureau. La plupart des pilotes et utilitaires commerciaux sont disponibles sous forme de versions exécutables. Vous obtenez un fichier binaire. Vous l’exécutez. Vous ne voyez pas le code. Vous ne pouvez pas l’étudier. Vous ne pouvez pas le modifier. C’est une boîte noire.
L’Open Source inverse ce script. Les documents sources originaux sont disponibles. Vous pouvez les lire. Vous pouvez les adapter. Vous pouvez créer quelque chose de nouveau dessus et le partager. C’est un cycle de transparence. Cette philosophie a donné naissance aux outils que nous tenons souvent pour acquis. GIMP pour la manipulation d’images. LibreOffice pour ceux qui refusent de payer pour Word. Apache, le moteur qui alimente une grande partie du Web.
Les jardins clos de Mobile
Regardez votre téléphone. Vous voyez à quel point l’interface est propre ? C’est par conception. Les appareils grand public cachent délibérément le système d’exploitation. Pourquoi? Parce que les utilisateurs vont casser des choses. Ils supprimeront les composants essentiels. Ils vont bricoler leurs propres appareils en essayant d’« optimiser » ce qui n’est pas cassé.
Les fabricants le verrouillent donc. Mais ils laissent une fissure dans la porte. Un « mode développeur » ou « mode programmeur ». Si vous savez où chercher, vous pouvez y accéder. Cependant, une fois que vous y êtes, la laisse est courte. Vous êtes autorisé à apporter des modifications, mais uniquement dans une plage étroitement contrôlée. On ne vous donne pas les clés du royaume. Juste une clé de rechange pour le hangar.
Cela crée une étrange dichotomie. Sur le bureau, vous avez la liberté (et la responsabilité) de modifier. Sur mobile, vous bénéficiez de la commodité au détriment du contrôle. Quelle approche est la meilleure pour la santé à long terme de notre infrastructure numérique ? Les frontières s’estompent, mais le compromis fondamental demeure. Soit vous voyez les vitesses tourner, soit vous profitez simplement de la balade.
