Avant les systèmes d'exploitation, quel concept était utilisé pour les faire fonctionner? [fermé]

Les systèmes d’exploitation sont étroitement liés à l’architecture de l’ordinateur. Un système d’exploitation s’occupe de toutes les entrées et sorties d’un système informatique. Il gère les utilisateurs, les processus, la gestion de la mémoire, l’impression, les télécommunications, la mise en réseau, etc. Il envoie des données à un disque, à l’imprimante, à l’écran et à d’autres périphériques connectés à l’ordinateur.

Avant l'introduction du système d'exploitation,

Qu'est-ce qui a été utilisé dans les systèmes informatiques pour les faire fonctionner?

Quel concept a été utilisé pour le système d'exploitation dans notre évolution de l'ordinateur?

Les premiers ordinateurs ^† exécutaient un programme à la fois.

Les programmes ont été directement chargés à partir (par exemple) d'une bande de papier perforée.

Vous programmeriez les premiers ordinateurs ^† en définissant un grand nombre de commutateurs marche / arrêt.

Colosse:

Atlas:

Manchester:

^† J'utilise le mot "ordinateur" pour désigner le type d'appareil qui existe actuellement par milliards. Parmi ce grand nombre d'ordinateurs, presque tous sont infimes: des ordinateurs électroniques programmables électroniques avec des programmes enregistrés. Je suis sûr que la question initiale ne concerne pas la façon dont les personnes occupant le poste "Informatique" ont passé leur journée de travail. Entre ces deux types d’ordinateur, il existe une progression de périphériques intéressants non traités dans cette réponse.

Source: Histoire des systèmes d'exploitation

Les systèmes d'exploitation ont évolué en plusieurs phases ou générations distinctes correspondant à peu près aux décennies.

Les années 1940 - Premières générations

Les premiers ordinateurs numériques électroniques n'avaient pas de système d'exploitation. Les machines de l'époque étaient si primitives que les programmes étaient souvent entrés un à un sur des rangées de commutateurs mécaniques (cartes enfichables) . Les langages de programmation étaient inconnus (pas même les langages d'assemblage). Les systèmes d'exploitation étaient inconnus.

Les années 1950 - Deuxième génération

Au début des années 50, la routine s'était quelque peu améliorée avec l'introduction des cartes perforées. Les laboratoires de recherche de General Motors ont mis en place les premiers systèmes d'exploitation au début des années 50 pour leur IBM 701 . Le système des années 50 n'exécutait généralement qu'un travail à la fois. Celles-ci ont été appelées systèmes de traitement par lots à flux unique, car les programmes et les données ont été soumis par groupes ou par lots.

Source: http://en.wikipedia.org/wiki/History_of_operating_systems

Les ordinateurs les plus anciens étaient des ordinateurs centraux dépourvus de toute forme de système d'exploitation.

Chaque utilisateur utilisait la machine exclusivement pendant une période déterminée et arrivait à l'ordinateur avec un programme et des données, souvent sur des cartes papier perforées et des bandes magnétiques ou en papier. Le programme serait chargé dans la machine et celle-ci serait configurée pour fonctionner jusqu'à ce que le programme soit terminé ou en panne.

Les programmes peuvent généralement être débogués via un panneau de commande à l'aide d'interrupteurs à bascule et de voyants. On raconte qu'Alan Turing maîtrisait bien cette machine sur la première machine Manchester Mark 1 et qu'il tirait déjà la conception primitive d'un système d'exploitation des principes de la machine Universal Turing.

Pour revenir au début des systèmes informatiques, vous n'aviez pas un seul ordinateur, mais des ordinateurs centraux.

Ces ordinateurs centraux seraient exécutés sur des cartes perforées contenant votre programme (et souvent vos données). Les gens allouaient du temps sur ces systèmes, apportaient leurs cartes et les connectaient aux machines à traiter. La machine exécuterait le programme jusqu'à la fin, puis l'utilisateur suivant viendrait avec sa bande et ses cartes.

En gros, c'est comme ça que ça a marché.

1890-1950 - Fonctionnement inhérent au système Les ordinateurs les plus anciens avaient l'équivalent de ce qu'un système d'exploitation intégré les intègre maintenant. Vous (l'opérateur) faites également partie du système d'exploitation. Vous avez basculé les commutateurs de registre (ou utilisé une carte perforée) et échangé des câbles de bus (pensez au poste de téléphoniste de l’ancienne mode) et la mémoire était reliée (via des câbles physiques) directement à une ampoule (le moniteur du jour) et à des imprimantes ( stockage à long terme) de telle sorte que la sortie du programme s’éclaire et s’imprime directement sur l’appareil lorsqu’il est placé dans la mémoire tampon de sortie. Il n'y avait aucun pilote nécessaire pour ces choses parce que (en raison de la façon dont les câbles physiques étaient exécutés), ils "travaillaient" (il n'y avait pas non plus de moniteur en ces jours-ci). En fait, il resterait encore quelques décennies avant qu'un écran numérique soit inventé afin que vous puissiez voir les nombres que vous aviez déjà entrés dans le registre et la sortie sous forme de nombres décimaux; les imprimeurs ont régné toute cette époque jusqu'à ce que les écrans soient. Ils ont été câblés exactement comme ils le devaient pour fonctionner correctement. Aucune partie de cette partie n'a vraiment beaucoup changé avec le passage de la mécanique (années 1890) à l'analogique électrique (années 1910) au numérique (années 1930). Cette architecture «Plug N Play» a été remplacée par le système d’interruption pendant cette période et ne refait surface que vers la fin des années 90; bien sûr, à ce moment-là, il y aurait beaucoup moins de problèmes. Avec les interruptions, les périphériques étaient autorisés à prendre du temps de calcul, ce qui permettait à des architectures qui t directement lié au matériel, mais il a fallu plusieurs générations pour que ce soit vraiment le processus simplifié que nous voyons dans x86 arch (et plus récent); Les premiers systèmes étaient souvent confrontés à des conditions de concurrence horribles, à des problèmes de délai de compatibilité matérielle et de compatibilité matérielle, ainsi qu'à d’autres comportements anormaux en matière d’interruption. Parce que chaque machine utilisait des architectures radicalement différentes (expérimentales) au cours de cette période; presque tous les appareils ont été conçus sur mesure pour la machine sur laquelle ils ont travaillé.

1950-1973 - Fonctionnement dans un système Cette époque a vu l'avènement de la plupart des fonctionnalités auxquelles nous pensons lorsque nous parlons d'un véritable système d'exploitation. Le débogage, les langages de programmation, les utilisateurs multiples, les tâches multiples, les terminaux, les disques durs, les réseaux, la normalisation des composants, etc. ont tous été introduits à cette époque. Cette fois, nous avons assisté à un pas de géant en matière de normalisation, ce qui signifie que nous avions davantage de périphériques normalisés, mais que chaque système d'exploitation était conçu à la main pour chaque machine, ce qui signifiait que la fonctionnalité du système d'exploitation était sévèrement limitée par les ingénieurs qui avaient conçu ce système particulier. . Pendant ce temps, il y avait une zone grise substantielle dans ce qu’était un système d’exploitation car les différentes architectures géraient les choses très différemment et une machine à usage général aurait besoin de beaucoup plus de système d’exploitation que d’une machine comprenant du matériel pour gérer les mêmes tâches. Le fait est que le matériel va toujours être plus rapide qu'un logiciel et que pratiquement tout ce qui est fait en logiciel peut théoriquement être fait en matériel (c'est le coût \ flexibilité \ taille \ temps \ etc. qui nous empêche de créer des versions matérielles presque pures de tout journée). Un système d'exploitation a été conçu pour un ordinateur ou un type d'ordinateur particulier; ça ne marcherait pas ailleurs. Chaque nouvelle conception informatique nécessitait que tous les logiciels de bas niveau soient réécrits à partir de zéro pour fonctionner avec un modèle de machine particulier. Vers la fin de cette période, un nouveau système d'exploitation est apparu qui allait bientôt changer ce paradigme, UNIX écrit aux Bell Labs par Ken Thompson et Dennis Ritchie.

1973 - Fonctionnement entre systèmes Un seul programme a changé tout cela, mais ce n'était pas UNIX. C'était le compilateur C (qui avait été créé dans un garage par Ken Thompson et Dennis Ritchie après que Bell Labs l'ait coupé). Jusque-là, chaque fois que vous écriviez du code, il s'agissait soit d'un code machine (code que la machine comprend directement mais n'est pas portable), soit écrit dans un langage compilant votre code en code octet (code interprété par un autre programme fonctionne). La grande différence pour les systèmes d’exploitation apportés par C était la possibilité de faire ce que l’on appelle la compilation croisée en code machine. Cela signifiait que le code pouvait être écrit une fois et compilé pour fonctionner de manière native sur de nombreux types de machines différents tant qu'un compilateur avait été écrit pour cette machine. Les systèmes d'exploitation doivent être écrits en code machine car ce dernier est littéralement le seul code connu de la machine.

Je dirais que ce n’est que lorsque Ken et Dennis ont compilé pour la première fois le noyau UNIX avec un compilateur C qu’un véritable système d’exploitation est né. Auparavant, un système d'exploitation était soit un objet physique, soit simplement un bloc d'espace mémoire pré-initialisé conçu spécifiquement pour une machine particulière. L'ajout de nouveaux périphériques au système nécessitait littéralement que le code "noyau" soit réécrit. Maintenant, le système d'exploitation UNIX qu'ils avaient conçu pour une machine particulière pouvait être recompilé et exécuté sur d'autres machines sans réécrire TOUT (tant que cette machine était capable de compiler un compilateur C à partir d'un environnement bootstrap, le reste du système d'exploitation pouvait être écrit). le code C relativement élevé).

Au début, les programmes étaient câblés dans l'ordinateur, ce qui le lançait immédiatement à partir d'un emplacement particulier au démarrage.

Ensuite, diverses formes de stockage hors ligne ont été inventées: cartes perforées, bandes, tambours, voire disques. Beaucoup plus souple. Mais pas directement accessible depuis la CPU. Le programme doit être chargé en mémoire avant de pouvoir être exécuté. Donc, vous écrivez un programme pour charger votre programme. C'est ce qu'on appelle un chargeur ou un bootstrap (de l'expression "se tirer par les courroies").

Au fur et à mesure que le système se complique, vous pouvez avoir un simple chargeur pour charger un chargeur plus complexe. Cela a commencé avec les micro-ordinateurs: le chargeur de bande normal était lent, chargez donc un décompresseur et chargez rapidement le reste de la bande. Ou encore des chargeurs rapides de disque qui faisaient également office de systèmes de protection contre la copie en faisant des choses non standard avec le disque.

Ou le processus de démarrage du PC pré-UEFI: le processeur commence à s'exécuter dans le BIOS. Cela charge le premier secteur du disque et y saute. Cela cherche une partition active et charge un chargeur de démarrage à partir de là, qui charge le système d'exploitation. À l'origine, cela aurait été COMMAND.COM pour MSDOS; à présent, il s’agit généralement de NTLDR.EXE pour Windows.

Il convient de noter que dans les premiers matériels (avant 1960), les E / S étaient beaucoup plus simples. Vous pouvez lire une carte, perforer une carte ou imprimer une ligne sur l’imprimante, chacune avec une seule instruction: la taille de la mémoire tampon est fixée et, souvent, l’adresse de la mémoire tampon est également corrigée.

Même au début des années 60, avec des processeurs plus sophistiqués (par exemple, le 7090), vous pouviez toujours lire ou perforer des cartes avec une petite routine (environ 20 instructions), qui était facilement copiée dans chaque programme.

Etant donné que l’ordinateur était entièrement dédié à un seul travail, peu importait que le processeur soit inactif en attendant que le lecteur de carte soit prêt à lire la carte suivante ou que l’imprimante par ligne alimente la ligne suivante.

Eh bien, cela importait, car le temps de calcul était coûteux. C'est pourquoi les gens ont inventé le multitraitement, le partage de temps, l'ajout d'E / S asynchrones, ainsi que les interruptions, les pilotes de périphérique et les systèmes d'exploitation. Les interfaces de périphériques matériels sont devenues plus complexes pour le programmeur, donnant accès à des registres d'E / S de niveau inférieur, ce qui nécessitait davantage de complexité de la part des pilotes de périphériques. Ce coût de complexité (mémoire, temps de programmation) a été amorti sur plusieurs programmes utilisant les périphériques "simultanément", multiplexés par le système d'exploitation.

Encore dans les années 80, j'utilisais un ordinateur à microprocesseur, émulant l'un de ces systèmes plus anciens. Les instructions de la machine avaient un format uniforme sur 80 bits (10 octets), et l'instruction de lire le premier secteur du premier disque dur et de le stocker dans la mémoire à l'adresse 0 était très pratique: 0000000000. La procédure de démarrage consistait donc tous les matins taper cette instruction sur le terminal, qui l’a stockée à l’adresse 0 et l’a exécutée, laquelle a ensuite chargé le secteur de démarrage et poursuivi l’exécution à l’instruction suivante (à l’adresse 10). Le système de fichiers consistait en un fichier de correspondance de table statique "noms" avec des plages de secteurs, qui étaient alloués manuellement! Les entrées / sorties ont été effectuées en assembleur sur ces fichiers en lisant ou en écrivant directement les secteurs, compensés par la position du fichier sur le disque dur qui a été récupéré par le "

La première génération d'ordinateurs conçus pour un usage personnel plus large avait ce que l'on appelle "Moniteur" en ROM (mémoire à lecture seule).

Immédiatement après le démarrage, le moniteur fournissait une interface de ligne de commande très limitée, principalement pour charger un programme à partir du stockage de données, tel qu’un enregistreur sur bande, et pour lancer l’exécution (quelques autres commandes étaient disponibles pour la saisie de code manuelle, bien que rarement nécessaires). Un seul programme peut être exécuté à la fois.

Contrairement au système d'exploitation, Monitor n'a pris en charge aucun type de système de fichiers. L’opérateur humain était responsable de trouver la bonne bande, de la placer sur l’enregistreur et de la positionner au début du programme à charger.

Surveiller les fonctions combinées du BIOS et du système d'exploitation et était déjà très clairement un logiciel.

Après la mise sous tension, le court signal de "réinitialisation" remettait simplement à zéro le compteur de programme comme tout autre compteur, tout en commutant en même temps le mappeur de mémoire (s'il en existait un) pour mapper l'adresse 0000 sur la ROM du moniteur. Il était courant de disposer ultérieurement d'un circuit matériel pour remapper Monitor dans l'espace d'adressage élevé. Outre le démarrage du code, le bouton "Réinitialiser" a également été utilisé pour terminer le programme en cours afin qu'un autre puisse être chargé.

Le bouton "réinitialiser" rudimentaire peut être trouvé sur certains ordinateurs de bureau, même de nos jours.

Le prédécesseur le plus direct du système d’exploitation combinerait des bibliothèques standard pour l’interfaçage avec des périphériques et le système du chargeur d’amorçage pour obtenir un programme mis en mémoire et démarré.