Sistemi operativi/Funzioni base: differenze tra le versioni
Contenuto cancellato Contenuto aggiunto
Nessun oggetto della modifica |
|||
Riga 13:
I programmi applicativi avevano accesso diretto a tutto l'hardware, tipicamente tramite librerie di routine di input/output.
=== Il caricatore ===
Ci si rese rapidamente conto che tale procedimento era inefficiente, perché mentre l'operatore sostituiva i nastri e le schede l'elaboratore era inutilizzato. Inoltre, per sfruttare l'elaboratore, occorreva la presenza continua di un operatore.
Pertanto, si passò in seguito al seguente procedimento.
Riga 30:
Questo software di base era un semplice caricatore ("loader"), ma, pur occupando poca memoria principale, consentiva una notevole riduzione dei tempi morti, a condizione che i programmi fossero corretti.
=== Il monitor residente ===
Un problema emerso con l'uso del caricatore era la presenza di errori nel software applicativo.
Quando l'elaboratore era completamente gestito da un programma per volta, qualunque cosa facesse tale programma, non danneggiava gli altri programmi. Comunque, se un programma non aveva finito la sua esecuzione dopo il tempo previsto, l'operatore lo arrestava e passava al programma successivo.
Riga 41:
* Sovrascrivere la parte di memoria principale in cui risiede il caricatore o i suoi dati.
Per rimediare a tali problemi, si
* L'aggiunta di schede di controllo tra le sequenze di schede contenenti programmi e dati.
* La protezione hardware delle risorse (processore, memoria principale, unità a nastri).
* L'utilizzo di un sistema operativo più sofisticato, chiamato "monitor".
==== Le schede di controllo ====
Siccome i primi elaboratori leggevano i dati direttamente dalle schede, e siccome anche successivamente la preparazione iniziale dei dati avveniva perforando schede che poi venivano riversate su nastri, anche il contenuto dei nastri di ingresso era organizzato come una sequenza di record, ognuno corrispondente a una scheda.
Per analogia, tali record venivano talvolta chiamati "schede".
Il nastro di ingresso conteneva una sequenza di elaborazioni (dette anche "job").
Ogni elaborazione era composta dal codice di un programma seguito dai suoi dati.
Per identificare l'inizio del programma e l'inizio dei dati, si usavano degli appositi record.
Pertanto, il primo record identificava l'inizio di un programma, poi c'erano i record che contenevano il codice del programma, poi il record di inizio dati, e poi i record contenenti i dati.
Dopo di ciò, la sequenza si ripeteva per l'elaborazione successiva.
Inizialmente i programmi erano scritti sono in linguaggio macchina, ma rapidamente si passò al linguaggio assemblativo, al FORTRAN e al COBOL, e poi ad altri linguaggi di programmazione.
Pertanto, la scheda di inizio programma doveva indicare anche in quale linguaggio era scritto il programma stesso.
Altre informazioni contenute nel record di inizio elaborazione erano i requisiti del programma, cioè la quantità di memoria necessaria, la durata massima dell'elaborazione, e il numero massimo di record che verranno emessi come risultato.
==== La protezione hardware ====
La protezione hardware è l'insieme di dispositivi elettronici che assicurano che un programma applicativo non possa eseguire operazioni che danneggino l'esecuzione di altri programmi.
Si suddivide in: protezione della CPU, protezione della memoria, protezione di ingresso/uscita.
La protezione della memoria consiste in un circuito che verifica ogni accesso alla memoria e blocca il programma se utilizza indirizzi di memoria inferiori a una soglia fissata.
Il sistema operativo si trova interamente nella memoria bassa, cioè sotto la soglia.
Usando tale protezione, nessun programma applicativo può sovrascrivere la memoria occupata dal sistema operativo stesso.
Ogni tentativo del genere provocherebbe l'immediata terminazione del programma applicativo e il passaggio al programma successivo.
La protezione del processore consiste in un timer che viene attivato all'inizio dell'elaborazione con un valore pari al tempo massimo previsto per l'elaborazione.
Se l'elaborazione termina prima che il timer abbia esaurito il suo tempo, il timer viene spento.
Se invece il timer scatta quando l'elaborazione è ancora in corso, il controllo passa al sistema operativo che termina l'esecuzione del programma e passa il controllo al programma successivo.
La protezione di ingresso/uscita consiste nel fatto che i programmi applicativi non possono effettuare direttamente operazioni di ingresso/uscita, ma possono solo richiedere al sistema operativo di effettuare tali operazioni.
Quando il sistema operativo riceve una richiesta del genere, valuta se rispetta i requisiti dell'applicazione, e in caso affermativo la effettua per conto dell'applicazione e poi torna il controllo all'applicazione.
==== Il flusso di controllo del sistema operativo ====
| |||