Prima dei sistemi operativi, quale concetto veniva utilizzato per farli funzionare? [chiuso]

I sistemi operativi sono stati strettamente correlati all'architettura del computer. Un sistema operativo si occupa di tutti gli input e output in un sistema informatico. Gestisce utenti, processi, gestione della memoria, stampa, telecomunicazione, reti ecc. Invia dati a un disco, alla stampante, allo schermo e ad altre periferiche collegate al computer.

Prima dell'introduzione del sistema operativo,

Cosa è stato usato nei sistemi informatici per farli funzionare?

Quale concetto è stato utilizzato per il sistema operativo nella nostra evoluzione del computer?

I primi computer ^† eseguivano un programma alla volta.

I programmi sono stati caricati direttamente da (ad esempio) nastro di carta con fori praticati al suo interno.

Programmeresti i primi computer ^† impostando un ampio set di interruttori on-off.

Colosso:

Atlante:

Manchester:

^† Sto usando la parola "Computer" per indicare il tipo di dispositivo che esiste oggi nei miliardi. Di questo vasto numero di computer, tutti tranne un numero irrilevante sono computer elettronici digitali programmabili con programmi memorizzati. Sono sicuro che la domanda originale non riguarda il modo in cui le persone con il titolo di lavoro "Computer" hanno trascorso la giornata lavorativa. Tra questi due tipi di computer, c'è una progressione di dispositivi interessanti non trattati in questa risposta.

Fonte: storia dei sistemi operativi

I sistemi operativi si sono evoluti attraverso una serie di fasi o generazioni distinte che corrispondono all'incirca ai decenni.

Gli anni '40 - Prime generazioni

I primi computer digitali elettronici non avevano sistemi operativi. Le macchine dell'epoca erano così primitive che i programmi venivano spesso inseriti un po 'alla volta su file di interruttori meccanici (schede plug) . I linguaggi di programmazione erano sconosciuti (nemmeno i linguaggi di assemblaggio). I sistemi operativi erano inauditi.

Gli anni '50 - Seconda generazione

All'inizio degli anni '50, la routine era leggermente migliorata con l'introduzione delle schede perforate. I General Motors Research Laboratories hanno implementato i primi sistemi operativi nei primi anni '50 per il loro IBM 701 . Il sistema degli anni '50 generalmente svolgeva un lavoro alla volta. Questi sono stati chiamati sistemi di elaborazione batch a flusso singolo perché i programmi e i dati sono stati inviati in gruppi o batch.

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

I primi computer erano mainframe privi di qualsiasi forma di sistema operativo.

Ogni utente ha usato la macchina per un periodo di tempo programmato e sarebbe arrivato al computer con programma e dati, spesso su schede di carta perforate e nastro magnetico o di carta. Il programma verrebbe caricato nella macchina e la macchina verrebbe impostata fino a quando il programma non veniva completato o arrestato in modo anomalo.

I programmi possono generalmente essere sottoposti a debug tramite un pannello di controllo utilizzando interruttori a levetta e luci del pannello. Si dice che Alan Turing ne fosse un maestro nella prima macchina di Manchester Mark 1, e già stava derivando la concezione primitiva di un sistema operativo dai principi della macchina di Universal Turing.

Tornando all'inizio dei sistemi informatici non avevi sistemi a singolo computer, invece avevi mainframe.

Questi mainframe verrebbero eseguiti su schede perforate che conterrebbero il tuo programma (e spesso i tuoi dati). Le persone ricevono tempo assegnato su questi sistemi, portano le loro carte e le inseriscono nelle macchine per l'elaborazione. La macchina avrebbe eseguito il programma fino al termine, quindi l'utente successivo sarebbe arrivato con il suo nastro e le carte.

Fondamentalmente è così che ha funzionato.

1890-1950 - Operazione inerente al sistema I primi computer avevano l'equivalente di ciò che un sistema operativo ora incorpora in essi. Anche tu (l'operatore) facevi parte del sistema operativo. Hai girato gli interruttori di registro (o hai usato una scheda perforata) e scambiato fisicamente i cavi del bus (pensa alla vecchia stazione dell'operatore telefonico di moda) e la memoria era collegata (tramite cavi fisici) direttamente con la lampadina (il monitor del giorno) e le stampanti ( l'archiviazione a lungo termine) in modo tale che l'output del programma si accendesse e stampasse direttamente sul dispositivo mentre veniva inserito nel buffer di memoria di output. Non c'era bisogno di driver per queste cose perché (a causa del modo in cui quei cavi fisici venivano fatti funzionare) "funzionavano" (ai giorni nostri non esisteva nemmeno un monitor). In effetti ci sarebbero voluti ancora alcuni decenni in questa era fino a quando non sarebbe stato inventato un display numerico digitale in modo da poter effettivamente vedere i numeri che avevi già inserito nel registro e l'output come numeri decimali; le stampanti hanno dominato l'intera epoca fino ai monitor. Erano cablati esattamente come dovevano essere per funzionare correttamente. Nessuna di queste parti è cambiata molto con il passaggio da meccanico (1890) a analogico elettrico (1910) a digitale (1930). Questa architettura 'Plug N play' è stata sostituita con il sistema di interruzione durante questo periodo e non riemergerà più fino alla fine degli anni '90; ovviamente a quel punto ci sarebbero stati molti meno collegamenti. Con gli interrupt, ai dispositivi è stato permesso di impiegare il tempo della CPU che ha permesso alle architetture che direttamente legato all'hardware ma ci sono volute diverse generazioni perché questo sia davvero il processo semplificato che vediamo in x86 arch (e più recenti); i primi sistemi spesso si imbattevano in condizioni di gara orribili, problemi di compatibilità hardware / ritardo e altri comportamenti strani per quanto riguarda gli interrupt. Perché ogni macchina usava architetture radicalmente diverse (una sperimentale) in questo periodo; quasi tutti i dispositivi sono stati realizzati su misura per la macchina su cui hanno lavorato.

1950-1973 - Funzionamento all'interno di un sistema Questa era ha visto l'avvento della maggior parte delle funzionalità che pensiamo quando parliamo di un vero sistema operativo. Debug, linguaggi di programmazione, multi-utenti, multi-tasking, terminali, unità del tipo di disco, reti, standardizzazione dei componenti, ecc. Sono stati tutti introdotti in questa era. Questa volta si è assistito a un enorme balzo in avanti verso la standardizzazione di gran parte di ciò, il che significava che avevamo dispositivi più standardizzati, ma ogni sistema operativo era stato realizzato a mano per ogni macchina, il che significava che la funzionalità del sistema operativo era fortemente limitata da qualsiasi cosa gli ingegneri che progettavano quel particolare sistema decidessero di cui avevano bisogno . Durante questo periodo, c'era una sostanziale area grigia in quello che era un sistema operativo perché le diverse architetture gestiscono le cose in modo molto diverso e una macchina per scopi più generali avrà bisogno di molto più SO di una macchina che include hardware per gestire gli stessi lavori. Il fatto è che l'hardware sarà sempre più veloce del software e praticamente qualsiasi cosa fatta nel software può teoricamente essere fatta nell'hardware (è il costo \ flessibilità \ dimensione \ tempo \ ecc. Che ci limita dal realizzare versioni hardware quasi pure di tutto a questo giorno). È stato creato un sistema operativo per un determinato computer o tipo di computer; non funzionerebbe altrove. Ogni nuovo design del computer aveva bisogno di riscrivere da zero tutto il software del sistema operativo di basso livello per funzionare con un modello di macchina particolare. Verso la fine di questo periodo emerse un nuovo sistema operativo che avrebbe presto cambiato questo paradigma, UNIX scritto a Bell Labs da Ken Thompson e Dennis Ritchie.

1973 - Funzionamento tra sistemi Un singolo programma ha cambiato tutto questo ma non era UNIX. Era il compilatore C (che è stato reso famoso in un garage da Ken Thompson e Dennis Ritchie dopo che Bell Labs lo ha tagliato). Fino a questo punto, ogni volta che scrivevi codice era o codice macchina (codice che la macchina capisce direttamente ma non è portatile) o è stato scritto in una lingua che ha compilato il tuo codice in codice byte (codice che viene interpretato da un altro programma in quanto corre). L'enorme differenza per i sistemi operativi che C portava con sé era la capacità di fare ciò che è noto come compilazione incrociata nel codice macchina. Ciò significava che il codice poteva essere scritto una volta e compilato per essere eseguito in modo nativo su molti diversi tipi di macchina purché fosse stato scritto un compilatore per quella macchina. I sistemi operativi devono essere scritti nel codice macchina perché il codice macchina è letteralmente l'unico codice che la macchina conosce.

Direi che non è stato fino a quando Ken e Dennis non hanno compilato il kernel UNIX per la prima volta usando un compilatore C che è nato un vero sistema operativo in senso moderno. Prima di allora, un sistema operativo era un oggetto fisico o semplicemente un pezzo di spazio di memoria preinizializzato progettato specificamente per una determinata macchina. L'aggiunta di nuovi dispositivi al sistema richiedeva letteralmente la riscrittura del codice "kernel". Ora, il sistema operativo UNIX che avevano progettato per una determinata macchina poteva essere ricompilato ed eseguito su altre macchine senza riscrivere TUTTO (fintanto che quella macchina era in grado di compilare un compilatore C da un ambiente bootstrap, il resto del sistema operativo poteva essere scritto in il codice C di livello relativamente alto).

All'inizio, i programmi erano cablati nel computer, che avrebbe iniziato a eseguire il programma immediatamente da una posizione particolare all'avvio.

Quindi sono state inventate varie forme di archiviazione offline: schede perforate, nastro, batteria, persino dischi. Molto più flessibile. Ma non direttamente accessibile dalla CPU. Il programma deve essere caricato in memoria prima di poter essere eseguito. Quindi scrivi un programma per caricare il tuo programma. Questo è noto come caricatore o bootstrap (dall'espressione "to pull up by your boot strap").

Man mano che il sistema diventa più complicato, è possibile che un semplice caricatore carichi un caricatore più complesso. Questo è iniziato con i microcomputer: il normale caricatore di nastri era lento, quindi carica un decompressore e carica velocemente il resto del nastro. O speedloader del disco che sono raddoppiati come sistemi di protezione dalla copia facendo cose non standard con il disco.

O il processo di avvio del PC pre-UEFI: il processore inizia l'esecuzione nel BIOS. Questo carica il primo settore dal disco e passa a esso. Che cerca una partizione attiva e carica un bootloader da lì, che carica il sistema operativo. Inizialmente sarebbe stato COMMAND.COM per MSDOS; ora è in genere NTLDR.EXE per Windows.

Va notato che nei primi hardware (prima del 1960), l'I / O era molto più semplice. È possibile leggere una scheda o perforare una scheda o stampare una riga sulla stampante, ognuna con una singola istruzione: la dimensione del buffer è stata corretta e spesso anche l'indirizzo del buffer è stato corretto.

Anche nei primi anni '60, con processori più sofisticati (ad es. Il 7090), era ancora possibile leggere o perforare le carte con una piccola routine (circa 20 istruzioni), che veniva facilmente copiata in ciascun programma.

Poiché il computer era interamente dedicato a un singolo lavoro, non importava se il processore era inattivo mentre aspettava che il lettore di schede fosse pronto per leggere la scheda successiva o che la stampante di linea potesse alimentare la riga successiva.

Bene, importava, perché in realtà il tempo di elaborazione era costoso. Questo è il motivo per cui le persone hanno inventato l'elaborazione multipla, la condivisione del tempo, l'aggiunta di I / O asincroni, interruzioni e driver di dispositivo e sistemi operativi. Le interfacce hardware del dispositivo sono diventate più complesse, per il programmatore, dando accesso a registri I / O di livello inferiore, che richiedevano maggiore complessità dai driver del dispositivo. Questo costo di complessità (memoria, tempo di programmazione) è stato ammortizzato sui vari programmi utilizzando i dispositivi "contemporaneamente", moltiplicati per il sistema operativo.

Ancora negli anni 80 stavo usando un computer basato su microprocessore, emulando uno di quei sistemi più vecchi. Le istruzioni della macchina avevano un formato uniforme su 80 bit (10 ottetti) e le istruzioni per leggere il primo settore del primo disco rigido e memorizzarlo nella memoria all'indirizzo 0 erano molto convenienti: 0000000000. Quindi la procedura di avvio consisteva ogni mattina digitare questa istruzione sul terminale, che lo ha memorizzato all'indirizzo 0 ed eseguito, che quindi ha caricato il settore di avvio e ha continuato l'esecuzione all'istruzione successiva (all'indirizzo 10). Il file system consisteva in una tabella statica che associava i "nomi" dei file a intervalli di settori, che sono stati allocati manualmente! L'I / O è stato eseguito in assemblatore per quei file leggendo o scrivendo direttamente i settori, compensato dalla posizione del file sul disco rigido che è stato recuperato dal "

La prima generazione di computer progettati per un uso personale più ampio aveva il cosiddetto "Monitor" nella ROM (memoria di sola lettura).

Immediatamente dopo l'avvio, il monitor ha fornito un'interfaccia della riga di comando molto limitata per lo più per caricare il programma dall'archiviazione dei dati come il registratore e avviare l'esecuzione (alcuni altri comandi erano disponibili per l'immissione manuale del codice, mentre raramente erano necessari). È possibile eseguire un solo programma alla volta.

A differenza del sistema operativo, Monitor non aveva alcun supporto per il file system di alcun tipo. L'operatore umano era responsabile di trovare il nastro giusto, metterlo sul registratore e posizionarlo all'inizio del programma necessario da caricare.

Monitorare le funzioni combinate del BIOS e del sistema operativo ed era già molto chiaramente un software.

Dopo l'accensione, il breve segnale di "reset" stava semplicemente azzerando il contatore del programma come qualsiasi altro contatore, allo stesso tempo commutando il mappatore di memoria (se presente) per mappare l'indirizzo 0000 sulla ROM del monitor. Era comune avere un circuito hardware per rimappare Monitor nello spazio di indirizzi alto in seguito. Oltre all'avvio del codice, il pulsante "Ripristina" è stato utilizzato anche per terminare il programma in esecuzione in modo da poterne caricare un altro.

Il rudimentale pulsante "reset" può essere trovato su alcuni PC desktop anche in questi giorni.

Il predecessore più diretto al sistema operativo sarebbe una combinazione di librerie standard per l'interfacciamento con i dispositivi e il sistema caricatore di bootstrap per ottenere un programma portato in memoria e avviato.