Questo testo è pubblicato sotto licenza Creative

Tecno1
Tecnologie e Progettazione dei Sistemi Informatici e di Telecomunicazione
dai numeri binari ai Sistemi Operativi
Paolo Macchi
ISIS Cipriano Facchinetti Castellanza – 2013-16
1 - Tecno1 rel. 17.03.17
Prometeo, (in greco antico Promethéus, «colui che riflette prima») era un Titano, un gigante fortissimo, ed era amico del genere umano. Era un cugino di Zeus e
non andava molto d'accordo con lui, perché a quel tempo il re dell'Olimpo voleva cancellare gli uomini dalla Terra.
I Titani si ribellarono a Zeus, ma Prometeo (che aveva previsto la sconfitta dei Titani) e suo fratello Epimeteo («colui che riflette dopo») si schierarono dalla sua
parte e questo permise a Prometeo di diventare amico degli altri dei, come Atena che gli insegnò molte bellissime arti come l'architettura, l'astronomia, la
matematica, la medicina, la metallurgia e la navigazione che poi Prometeo insegnò agli umani.
Prometeo e suo fratello ricevettero dagli dei un numero limitato di "buone qualità" da distribuire saggiamente fra tutti gli esseri viventi. Epimeteo (che non usava
molto la testa!) cominciò a distribuire le qualità agli animali ma si dimenticò degli uomini, così Prometeo, per rimediare, decise di rubare dalla casa di Atena uno
scrigno in cui erano riposte l'intelligenza e la memoria, e le donò alla specie umana.
Zeus non fu contento di questo gesto: così gli umani sarebbero stati più difficili da sterminare!
Come ulteriore punizione Zeus tolse il fuoco agli uomini e lo nascose.
Prometeo si recò allora da Atena affinché lo facesse entrare di notte nell'Olimpo e appena giunto, accese una torcia dal carro di Elio (che teneva il sole) e si
dileguò senza che nessuno lo vedesse.
Il padre degli dei fece incatenare Prometeo, nudo, con lacci d'acciaio nella zona più alta e più esposta alle intemperie del Caucaso e gli venne conficcata una
colonna nel corpo. Inviò poi un'aquila perché gli squarciasse il petto e gli dilaniasse il fegato, che gli ricresceva durante la notte, giurando di non staccare mai
Prometeo dalla roccia.
Dopo tremila anni, Eracle (il mitico Ercole!) passò dalla regione del Caucaso, trafisse con una freccia l'aquila che lo tormentava e liberò Prometeo, spezzando le
catene.
[tratto da http://www.focusjunior.it/W_la_scuola/Navigo_e_imparo/2010/novembre/miti-greci-prometeo-il-gigante-che-amava-l-umanita.aspx]
La parola tecnologia (formata da tecno, ovvero arte e da logia,ossia discorso) e indica “l’intero settore di ricerca, nel quale sono coinvolte varie discipline tecniche
e scientifiche, che studia l'applicazione e l'uso di tutto ciò che può essere funzionale alla soluzione di problemi pratici, all'ottimizzazione delle procedure, alla
scelta di strategie operative per raggiungere un determinato obiettivo”.
In particolare, le nuove tecnologie sono “alla base della società interconnessa e di quella che molti chiamano quarta rivoluzione industriale. Tecnologie che
abbracciano l’Internet of Things e il machine to machine, le reti di comunicazione di nuova generazione ma anche i dispositivi indossabili e la robotica”.
In particolare “ l’Internet of Things, conferma la sua veloce espansione in nuove aree di sviluppo quali la telemedicina e la home automation. Aree che si
affiancano a settori in cui i sistemi di comunicazione M2M e IoT sono già radicati, a cominciare dall’automotive con gli strumenti di localizzazione satellitare e
antifurto e tutti i servizi telematici di bordo. Nell’immediato futuro si apriranno nuovi scenari come l’Internet delle cose applicato al punto vendita. Città,
fabbriche e soprattutto edifici dovranno cambiare in nome e in funzione dell’interoperabilità e dell’interconnessione.”
2 - Tecno1 rel. 17.03.17
Indice Generale
Il digitale: ma di cosa stiamo parlando?....................................................................................................................................................................................................5
Il Sistema di Elaborazione..........................................................................................................................................................................................................................8
bit e byte....................................................................................................................................................................................................................................................8
Hardware.................................................................................................................................................................................................................................................10
Software...................................................................................................................................................................................................................................................10
Rappresentazione dei numeri naturali....................................................................................................................................................................................................11
Numerazione binaria...............................................................................................................................................................................................................................12
Conversione binario-decimale-binario....................................................................................................................................................................................................12
Numerazione esadecimale......................................................................................................................................................................................................................13
Conversione decimale-esadecimale-decimale........................................................................................................................................................................................13
Conversione binario-esadecimale-binario...............................................................................................................................................................................................14
Rappresentazione di numeri interi..........................................................................................................................................................................................................14
Somma binaria.........................................................................................................................................................................................................................................14
Somma in esadecimale............................................................................................................................................................................................................................15
Modulo e segno.......................................................................................................................................................................................................................................15
Complemento a 2....................................................................................................................................................................................................................................16
Sottrazione binaria in complemento a 2.................................................................................................................................................................................................17
Rappresentazione dei numeri reali.........................................................................................................................................................................................................18
Rappresentazione in virgola fissa............................................................................................................................................................................................................18
Conversione Decimale->Binario di numeri frazionari in virgola fissa......................................................................................................................................................18
Rappresentazione in virgola mobile (floating point- IEEE754)................................................................................................................................................................19
Conversione decimale –> floating point..................................................................................................................................................................................................20
Operazioni con la rappresentazione floating point.................................................................................................................................................................................20
Proprietà dell’aritmetica in virgola mobile..............................................................................................................................................................................................21
BCD..........................................................................................................................................................................................................................................................22
Comunicazione e Codici..........................................................................................................................................................................................................................23
Schema fondamentale della comunicazione...........................................................................................................................................................................................23
L’interazione uomo-macchina.................................................................................................................................................................................................................25
Informazione............................................................................................................................................................................................................................................26
Codici per la rilevazione e la correzione degli errori...............................................................................................................................................................................27
Codifica dei caratteri alfanumerici...........................................................................................................................................................................................................28
Lo standard ASCII.....................................................................................................................................................................................................................................29
Unicode....................................................................................................................................................................................................................................................30
Codice QR................................................................................................................................................................................................................................................31
codifica di immagini e suoni....................................................................................................................................................................................................................32
Immagini..................................................................................................................................................................................................................................................32
Grafica Digitale........................................................................................................................................................................................................................................33
Grafica Raster (bitmap)............................................................................................................................................................................................................................33
Grafica vettoriale.....................................................................................................................................................................................................................................34
Suoni........................................................................................................................................................................................................................................................36
Compressione dati...................................................................................................................................................................................................................................37
Ottimizzazione dei messaggi...................................................................................................................................................................................................................37
Tecniche non distruttive (senza perdita di informazione).......................................................................................................................................................................38
Tecniche distruttive (con perdita di informazione).................................................................................................................................................................................40
Introduzione ai Sistemi Operativi............................................................................................................................................................................................................42
Cos’è un Sistema Operativo.....................................................................................................................................................................................................................42
Evoluzione................................................................................................................................................................................................................................................44
Prima generazione (1945-1955)..............................................................................................................................................................................................................44
Seconda generazione (1955 – 1965).......................................................................................................................................................................................................45
Terza generazione (1965 – 1980).............................................................................................................................................................................................................46
Quarta generazione (1980 – 1990 –> ai giorni nostri).............................................................................................................................................................................48
Sensori e MEMS.......................................................................................................................................................................................................................................50
Sensori.....................................................................................................................................................................................................................................................50
MEMS e IoT.............................................................................................................................................................................................................................................50
Struttura di un Sistema operativo...........................................................................................................................................................................................................54
Il modello onion skin...............................................................................................................................................................................................................................55
I PROCESSI................................................................................................................................................................................................................................................57
Definizione di processo............................................................................................................................................................................................................................57
Descrittore di processo (PCB)..................................................................................................................................................................................................................58
Interazioni tra processi............................................................................................................................................................................................................................59
Relazioni di precedenza...........................................................................................................................................................................................................................59
Sistemi multiprogrammati.......................................................................................................................................................................................................................60
Time sharing............................................................................................................................................................................................................................................62
Stati di un processo.................................................................................................................................................................................................................................62
Il nucleo...................................................................................................................................................................................................................................................64
Virtualizzazione CPU................................................................................................................................................................................................................................64
Scheduler – Algoritmi di scheduling........................................................................................................................................................................................................65
First Come First Served (FCFS).................................................................................................................................................................................................................65
Round Robin (RR).....................................................................................................................................................................................................................................66
Shortest job first......................................................................................................................................................................................................................................67
Meccanismo di priorità............................................................................................................................................................................................................................67
Thread......................................................................................................................................................................................................................................................68
La priorità in Windows.............................................................................................................................................................................................................................69
La priorità in Linux...................................................................................................................................................................................................................................70
Processi sequenziali e concorrenti..........................................................................................................................................................................................................71
3 - Tecno1 rel. 17.03.17
Corse critiche, Interferenza e Cooperazione...........................................................................................................................................................................................71
Sezioni critiche – Mutua esclusione........................................................................................................................................................................................................72
Soluzioni...................................................................................................................................................................................................................................................72
Semafori...................................................................................................................................................................................................................................................73
SEMAFORO BINARIO................................................................................................................................................................................................................................74
Mutua esclusione....................................................................................................................................................................................................................................74
Produttore / consumatore :.....................................................................................................................................................................................................................74
SEMAFORO GENERALIZZATO...................................................................................................................................................................................................................76
Produttore / consumatore con buffer multiplo.......................................................................................................................................................................................76
Problemi:.................................................................................................................................................................................................................................................77
Deadlock..................................................................................................................................................................................................................................................80
Primitive di Comunicazione tra Processi.................................................................................................................................................................................................82
Monitor....................................................................................................................................................................................................................................................83
Un monitor è …........................................................................................................................................................................................................................................83
Sincronizzazione di thread in Java...........................................................................................................................................................................................................83
I thread in Java.........................................................................................................................................................................................................................................83
Gestione della Memoria..........................................................................................................................................................................................................................86
Indirizzi di memoria fisici e logici.............................................................................................................................................................................................................86
Traduzione di indirizzi logici in fisici.........................................................................................................................................................................................................86
Memory-Management Unit (MMU)........................................................................................................................................................................................................86
Swapping.................................................................................................................................................................................................................................................87
Allocazione della memoria......................................................................................................................................................................................................................88
Allocazione contigua................................................................................................................................................................................................................................88
Allocazione non contigua........................................................................................................................................................................................................................89
segmentazione.........................................................................................................................................................................................................................................90
Memoria Virtuale....................................................................................................................................................................................................................................90
Paginazione su richiesta (Demand Paging)..............................................................................................................................................................................................91
Page Fault................................................................................................................................................................................................................................................91
File System...............................................................................................................................................................................................................................................94
Il concetto di file......................................................................................................................................................................................................................................94
File system...............................................................................................................................................................................................................................................94
Il File System Logico.................................................................................................................................................................................................................................94
File system fisico......................................................................................................................................................................................................................................96
Metodi di assegnazione dello spazio su disco.........................................................................................................................................................................................97
FAT File Allocation Table..........................................................................................................................................................................................................................97
Assegnazione indicizzata.........................................................................................................................................................................................................................98
NTFS.......................................................................................................................................................................................................................................................100
Protezione e sicurezza...........................................................................................................................................................................................................................102
Protezione..............................................................................................................................................................................................................................................102
Sicurezza................................................................................................................................................................................................................................................102
Autenticazione (controllo dell’accesso) degli utenti.............................................................................................................................................................................102
Minacce ai programmi...........................................................................................................................................................................................................................103
Tecno1 Dai numeri binari ai Sistemi Operativi
Questo testo è pubblicato sotto licenza Creative Commons - Attribuzione - Non commerciale - Condividi allo stesso modo 3.0 Unported - Per
le condizioni consulta: http://creativecommons.org/licenses/by-nc-sa/3.0/deed.it
Le utilizzazioni consentite dalla legge sul diritto d'autore e gli altri diritti non sono in alcun modo limitati da quanto sopra.
Il documento è scaricabile da , sezione download, per fini esclusivamente didattici e non commerciali. Il documento è scaricabile liberamente
da: http://moodle.isisfacchinetti.it/mod/data/view.php?d=21&rid=517
E’ possibile richiedere la dispensa in formato cartaceo, all'Ufficio Stampa dell'ISIS Facchinetti
Segnalazioni di errori, critiche e consigli sono molto graditi e possono essere inoltrati a [email protected], oppure lasciando un commento
al momento del download se siete registrati.
(in copertina : Theodoor Rombouts (1597-1637) – Prometheus)
Convenzioni usate nel testo:
rappresenta una curiosità, un approfondimento
NOTA rappresenta una nota
rappresenta una esercitazione o esempio
link di riferimento Rappresenta un codice o dei risultati o una segnalazione storica
4 - Tecno1 rel. 17.03.17
Il digitale: ma di cosa stiamo
parlando?
“Il digitale è strutturalmente incapace di sfumature. Deve atomizzare il mondo in frammenti piccoli…Il digitale pretende che tutto ciò che esiste sia
scomponibile in elementi 1 e 0 (perlomeno fino alla risoluzioni che riesci a percepire). Il digitale tratta il mondo come una cosa che si può replicare un
numero arbitrario di volte” [Jonah Lynch, Il profumo dei limoni. Tecnologia e rapporti umani nell’era di Facebook ]
1+1=0
“Di cosa stiamo parlando quando parliamo di digitale?
Si tratta in generale di metodi che permettono di tradurre un fenomeno analogico, fatto di infinite variazioni, in una sequenza di solo due elementi: 1 e 0, ‘ on and
off’.
Se ci si pensa è meraviglioso che un suono possa essere rappresentato molto fedelmente attraverso il procedimento digitale. Un suono è infinitamente variabile,
anche se si tratta di una dinamica estremamente semplice, quasi unidimensionale, perché è ‘solo’ la compressione e rarefazione dell’aria.
Una sola variabile, la pressione dell’aria, è in grado di trasmettere la stupenda ricchezza di una sinfonia, la inimitabile particolarità della voce della donna che
amo, o il suono estivo della cicala…
Questa ricchezza sonora posso convertirla in una stringa di bit, 1 e 0.
Si usa un approccio matematico che permette di approssimare una qualsiasi curva, la quale rappresenta la pressione dell’aria in singolo istante, con una serie di
funzioni semplici.
Se voglio mettere questa curva su un CD (o nella memoria del mio PC o trasmetterlo in Internet) devo prima convertire il segnale analogico (infinitamente
variabile) in una sequenza di bit. Per fare ciò uso la tecnica di Fourier. Se opero a qualità CD, uso 44100Hz, dunque misuro l’altezza della curva e ne registro il
valore 44100 volte al secondo.
E’ effettivamente un’ottima approssimazione ma anche a questo livello di precisione, perdo informazione: tutto ciò che succede TRA i momenti di misurazione
viene perso. La curva approssimata sarà poi interpretata dal lettore CD e tradotta in pressione dell’aria attraverso una cassa.
Il tutto si complica nel caso delle immagini. Per essere convertita in formato digitale, un’immagine deve essere tradotta in pixel, cioè in una serie di punti in cui si
rileva la quantità e il colore della luce. Sono “discreti”, dei punti separati che non hanno niente a che fare uno con l’altro. Ognuno di essi ha quindi un valore di
colore e di intensità che può essere convertito in numeri come si fa con la musica.
5 - Tecno1 rel. 17.03.17
E’ qualcosa di simile al punto e croce che faceva mia nonna – una griglia di stoffa, in cui ogni casella era riempita da una piccola croce di filo colorato, formava
una immagine.
Uno schermo fatto di pixel rende molto facile la produzione di linee rette lungo gli assi dello schermo. Basta una semplice curva e quell’immagine non è più tanto
bella”
Proviamo a vedere l’ingrandimento di qualche carattere di questa stessa pagina.
Ci si accorge subito che vengono usate delle tecniche per ingannare l’occhio che percepisce delle curve là dove c’è una scacchiera di pixel.
Non sempre il contorno della figura coincide con le linee della griglia. Quella che si ottiene nella codifica è un'approssimazione della figura originaria :
La rappresentazione sarà più fedele all'aumentare del numero di pixel, ossia al diminuire delle dimensioni dei quadratini della griglia in cui è suddivisa l'immagine
risoluzione dell’immagine.
_
Un calcolatore, per come è costruito, lavora solo con i valori 0 e 1. Le informazioni (numeri, testi, immagini, suoni. . . )che vogliamo rappresentare (e poter
elaborare) in un calcolatore devono perciò subire un processo di Codifica e Decodifica che permette di ottenere la loro rappresentazione
L’elemento base della rappresentazione binaria è il bit (binary digit, cifra binaria). Con un bit possiamo rappresentare un’informazione che può assumere 2 valori
Esempio Stato di una lampadina: 0 = spento, 1 = acceso (0 = falso, 1 = vero)
Una lampadine può trovarsi in soli due stati: accesa o spenta, ON o OFF. Ciò corrisponde a 2^1 (2 stati, 1 lampadina)
6 - Tecno1 rel. 17.03.17
Due lampadine hanno 4 stati (2^2):
Off
Off
On
On
Off
On
Off
On
con 3 lampadine otto stati (2^3) e in generale
Quindi:
1 bit 2 valori: 0, 1
2 bit 4 valori: 00, 01, 10, 11
3 bit 8 valori: 000, 001, 010, 011, 100, 101, 110, 111
In generale: n bit rappresentano 2^n stati ,
dove n è il numero degli elementi, in questo caso le lampadine.
In particolare, una matrice costituita da 20 righe di lampadine per 20 colonne, possiede 400 lampadine. Se ogni lampadina può essere accesa o spenta abbiamo:
2^400 stati possibili, cioè 10^120 stati, cioè 1 seguito da 120 zeri! (cfr Ross Ashby ).
Nota: Si pensi che la terra era in uno stato gassoso circa 5x10^9 anni fa, cioè 1.6x10^17 secondi, cioè 1.6x10^26ns (1nanosecondo è pari a 10^-9 secondi), ancora
molto lontani da 10^120, così come la stima del numero totale di atomi nell'universo visibile, pari a 1079 - 1085 .
Se poi consideriamo le possibili transizioni tra gli stati, cioè il numero di possibili modi in cui il sistema può passare da uno stato all’altro, il numero diventa
enorme…
Infatti , ad esempio, con due sole lampadine con quattro stati di partenza si possono avere 4 stati x 3 transizioni (senza considerare la transizione su se stessa),
cioè 12 transizioni possibili.
Con 20, lampadine e 400 stati si possono avere (2^400)! (! È il simbolo di fattoriale).
E un monitor quanti pixel ha???
Le semplici considerazioni fatte possono dare almeno una vaga idea della complessità dei sistemi, anche di quelli piu’ semplici!
Attraverso meccanismi di codifica possiamo rappresentare diversi tipi di informazione:
• Numeri naturali (insieme N)
• Numeri interi (insieme Z)
• Numeri razionali (insieme Q)
• caratteri
• immagini
• suoni
• video
Esistono diverse convenzioni (codifiche) per fornire a ciascun tipo di informazione una rappresentazione binaria come vedremo nei prossimi capitoli.
7 - Tecno1 rel. 17.03.17
Il Sistema di Elaborazione
I computer sono incredibilmente veloci, accurati e stupidi.
Gli uomini sono incredibilmente lenti, inaccurati e intelligenti.
L’insieme dei due costituisce una forza incalcolabile
- Albert Einstein fisico (1879-1955)
Un computer ti fa fare più errori e più velocemente di qualsiasi altra invenzione dell’uomo.
Con l’eccezione forse delle armi da fuoco e della tequila
- Mitch Ratcliffe (giornalista USA)
Un computer, chiamato anche, calcolatore o elaboratore digitale o sistema di elaborazione, o sistema informatico è un dispositivo fisico capace di memorizzare,
elaborare e trasmettere informazioni.
Un sistema di elaborazione può essere, approssimativamente visto come composto da un Hardware il cui funzionamento viene controllato da un Software
particolare chiamato Sistema Operativo.
L'hardware è rappresentato dai componenti fisici come il case, i dispositivi di memorizzazione, le tastiere, i monitor, i cavi, gli altoparlanti e le stampanti.
Il software è costituito da istruzioni – raccolte in programmi – che fanno svolgere al computer determinate funzioni.
Il sistema operativo ha il compito di dare istruzioni al computer su come operare. Ad esempio permette l’accesso ai file su disco e gestisce le periferiche e
l’esecuzione dei programmi.
Il sistema operativo si occupa di gestire la macchina, le sue risorse e i programmi che vi sono eseguiti, e fornisce all'utente un mezzo per inserire ed eseguire gli
altri programmi.
I programmi o applicazioni, svolgono svariate funzioni. Vanno dai giochi, all’accesso a Internet, a un foglio di calcolo a un editor di testo…
Le informazioni trattate da un sistema di elaborazione (numeri, parole suoni, immagini…) sono codificate in binario, cioè usano due soli simboli: 0 e 1 che i
dispositivi fisici del computer associano a due stati (ad esempio livelli di tensione: 0V e 5V).
bit e byte
L’informazione minima è il bit (binary digit) che assume i due stati differenti codificando una cifra binaria. I bit sono raggruppati in Byte (8 bit) multipli di esso. Il
bit è anche l’unità di misura dell’Informazione. (remixato, in parte, da : “Computer & Web” - Corriere della sera)
1bit –una goccia d’acqua
1 Byte -> un cucchiaio
1KB -> un secchio da 10 litri
1 MB -> una piccola piscina da 10000 litri
1 GB -> un lago 10 milioni di litri
multipli del bit e del Byte:
Nome
Abbreviazione
(binari) SI
Equivale a
Capacità
bit1
bit
Unità di misura dell’entropia
2ˆ0 bit =1 bit
byte
B
2ˆ3 bit = 8 bit
kilobyte
(KiB) kB
2^10 =1024 ≈
megabyte
(MiB) MB
2^20 =1048576 ≈
gigabyte
(GiB) GB
2^30 =1073741824 ≈
terabyte
(TiB) TB
2^40 ≈
10
petabyte
(PiB) PB
2^50 ≈
10
un carattere alfanumerico
103
circa 15 righe dattiloscritte
byte
byte
un libro di circa 500 pagine.
9
circa 500'000 pagine.
106
10
byte
12
byte
un milione di libri di 500 pagine ciascuno.
15
byte
180 volte la Biblioteca del Congresso2
1la parola deriva dalla contrazione dell'espressione inglese binary unit.
2Si trova a Washington D.C., negli Stati Uniti: con 28 milioni di volumi è la più grande biblioteca del mondo.
8 - Tecno1 rel. 17.03.17
Nome
Abbreviazione
(binari) SI
Equivale a
Capacità
exabyte
(EiB) EB
2^60 ≈
1018
byte
180'000 volte la Biblioteca del Congresso
zettabyte
(ZiB) ZB
2^70 ≈
1021
byte
180 milioni di volte la Biblioteca del Congresso
yottabyte
(YiB) YB
2^80 ≈
10
24
byte
180 miliardi di volte la Biblioteca del Congresso
(cfr per IEC International Standard Conversioni )
Ad esempio un file della dimensione di
1000byte corrisponde a:

8000 .......... bits

1000 .......... bytes (10^3 byte)

0.9765625 .. kilobytes (circa 1KB, cioè 8Kbit)

0.0009536743 megabytes (circa 10^-3 *10^6)

0.0000009313 gigabytes

0.0000000009 terabytes
100.000.000 Byte:
800 000 000 .......... bit
100 000 000 .......... byte (10^8byte)
97 656. 25 ....... kilobyte (circa 100 000 KB (10^5*10^3= 10^5 Kbyte ))
95.3674316406 megabyte (circa 100 MB (100*10^6 Byte))
0.0931322574 gigabyte ( 10^8 = 10^-1*10^9= .1 GB)
0.0000909494 terabyte (10^8 = 10^-4 *10^12)
0.0000000888 petabyte
Per comodità le conversioni in potenze di 2:
1.
Esercizi ():
un file musicale del tuo cantante preferito quanti byte occupa?
(Ex. “Years “ – Alesso – 4.24MB, )
2.
Dati 6 bit per la codifica, quante informazioni distinte si possono rappresentare?
26=64 informazioni distinti
3.
Dato un byte per la codifica, quante informazioni distinte si possono rappresentare?
Un byte = 8 bit, 28=256 informazioni distinti
4.
Quanti bit si devono utilizzare per rappresentare 20 informazioni distinte?
Almeno 5 bit, perché 25=32 => 20 (4 bit non sono sufficiente, perché 24=16 < 20)
5.
Un'immagine a 256 colori è formata da 400x400 pixel. Quanto spazio occupa?
Ogni pixel richiede un byte (=8 bit, perché 28=256, sufficiente per rappresentare 256 colori); l'immagine ha 400 x 400 = 160000 pixel; l'immagine occupa
160000 byte (= 1280000 bit)
6.
Problema: vuoi copiare i dati del tuo disco fisso su CD-ROM.
Nel disco fisso ci sono 5GB di dati (documenti, musica, fotografie, etc.) e tu hai in casa 3 CD-ROM da 700MB l'uno (capienza standard). Ti bastano per copiare i dati o devi andare a comprare altri CD?
Soluzione: vediamola insieme 3 CD x 700 Mbyte = 2.100 Mbyte hai in totale 2.100Mbyte a disposizione per il salvataggio. Convertendo i Mbyte in Gbyte
9 - Tecno1 rel. 17.03.17
(2*10^3*10^6 = 2*10^9 = 2Gbyte) scopri che hai a disposizione poco più di 2Gbyte mentre te ne servono 5! Risultato: non ti bastano, hai bisogno di altri
CD-ROM!
7.
Si desidera salvare su file un testo di 100 pagine, ognuna composta da 50 righe di 70 caratteri. Calcolare la dimensione del file espressa in KB e MB.
50*70=3.500 caratteri per pagina (= n. byte se ogni carattere è composto da 1 byte, cioè 8bit)
3.500*100=3.5 *10^5 = numero byte del testo pari a 350KB , pari a 0,35MB
8.
quanti diversi valori posso rappresentare con 5 bit?
Risposta: con 5 bit posso rappresentare 2^5 = 32 diversi valori.
9.
quanti diversi valori posso rappresentare con 2 byte?
2 byte = 16 bit, quindi posso rappresentare 2^16 = 65536 diversi valori.
10. quanti bit mi servono per rappresentare 1000 diversi valori?
devo trovare il minimo numero n di bit che soddisfi. 2^n > 1000, 2^10 = 1024, quindi n = 10.
11. quanti bit mi servono per rappresentare 112 diversi valori?
7 bit (2^7 = 128). 6 bit sarebbero stati pochi, mentre 8 bit sarebbero stati troppi!
Hardware
Le componenti hardware possono essere raggruppate in cinque tipologie:

i dispositivi di ingresso, per immettere i dati all'interno del computer;

i dispositivi di uscita, per visualizzare il contenuto del computer;

le unità di elaborazione, per svolgere le operazioni e coordinare tutti i componenti hardware;

le unità di memorizzazione, per l'archiviazione dei dati elaborati;

i bus, per veicolare le informazioni tra i componenti del computer.
Esistono vari tipi di computer: desktop, laptop (chiamato anche portatile, notebook), palmari (PDA - Personal Digital Assistant). Inoltre esistono grandi sistemi
informatici (mainframe e supercomputer) che sfruttano la presenza di elaboratori molto potenti che "prestano" le proprie capacità a dispositivi privi di
autonomia operativa (terminali) .
Nonostante vi siano state innumerevoli evoluzioni tecnologiche nell'hardware, alla base del funzionamento di un computer è sempre presente l'architettura della
macchina di von Neumann, risalente agli anni Quaranta del secolo scorso.
Software
Con software si identificano i programmi che devono essere installati sul calcolatore per eseguire operazioni specifiche. I programmi sono una sequenza di
operazioni elementari, dette istruzioni, che rispettano la sintassi di un dato linguaggio di programmazione. Si dividono in software di sistema (o di base) e
software applicativi.
Per riferirsi a gruppi di computer basati sullo stesso microprocessore e su caratteristiche di progetto simili, si usa l'espressione famiglia di computer.
In genere, computer di famiglie diverse non sono tra loro compatibili, cioè in grado di usare lo stesso sistema operativo e gli stessi programmi applicativi
Il software applicativo non può operare se il funzionamento del sistema non viene controllato e diretto dal software di sistema, che gestisce e sovrintende il
lavoro dei vari componenti e l'interazione tra di essi.
Il software di sistema più importante è il sistema operativo (SO), ma devono essere considerati appartenenti a questa categoria anche i compilatori per linguaggi
di programmazione, che servono per creare software applicativi.
È possibile dire che il sistema operativo funge da interfaccia tra il computer e l'utente, cioè offre all'utente tutti gli strumenti necessari per lo svolgimento delle
operazioni richieste, garantendo la gestione di tutte le risorse impiegate. L'interfaccia può essere di tipo testuale (come accade in MS-DOS) o di tipo grafico
(come accade nelle varie versioni di Windows).
Sono molte le operazioni e i controlli che vengono effettuati dal sistema operativo; tra i più importanti, vi è la gestione delle memorie e di tutti i componenti
10 - Tecno1 rel. 17.03.17
presenti nel sistema, compresa l'interazione e la comunicazione tra di essi. Ad esempio, è il sistema operativo a gestire le periferiche di input o di output, oppure
la memorizzazione nei vari supporti, nonché il controllo dei programmi aperti.
Attualmente esistono numerosi sistemi operativi, i più diffusi dei quali sono: Windows, MacOS, iOS, Android, Linux, Unix... Esiste il problema della compatibilità.
I software applicativi vengono creati e usati per svolgere determinate operazioni nei moltissimi campi nei quali può essere usato un computer : word processor o
elaboratori di testi, i programmi per l'elaborazione dei fogli elettronici, detti anche fogli di calcolo o spreadsheet, i sistemi per la gestione di basi di dati,
(Microsoft Office, Open Office,..),I programmi di grafica permettono di elaborare immagini (Corel Draw, Adobe PhotoShop, Graphics e Adobe
Illustrator,Gimp),Rappresentazione dell’ informazione numerica
Rappresentazione dei numeri naturali
Nel passato sono state adottate svariate notazioni numerali in gran parte poco razionali fino a giungere con una certa fatica alle notazioni oggi più diffuse: le
notazioni posizionali decimali.
Confrontiamo quanto accadeva nelle civiltà antiche basandoci su una spiegazione di Marco Bramanti.
La maggior parte delle civiltà (es. Greci, Romani, Indiani) numeravano in base 10, con riferimento all'atto di contare con le dita delle mani e basato
essenzialmente sul numero (V, una mano), additivo e non posizionale: il simbolo X (due mani) rappresenta sempre il numero dieci.
Ad esempio, un romano diceva “triginta quattuor” per dire “trentaquattro”, con la nostra stessa logica nostra: una parola per le decine, una per le unità.
Tuttavia la scrittura non sempre seguiva questa logica. Ad esempio per i Romani: “trentaquattro” si scriveva XXXIV: non bastava un simbolo per le decine e uno
per le unità. Il sistema romano non è un sistema con cifre, né è posizionale e risulta perciò impossibile fare le “operazioni in colonna”:
34 +
XXXIV +
47 =
XLVII =
81
???????
Occorre l’abaco, o un sistema di calcolo sulle dita!
I babilonesi usavano una numerazione in base 60, infatti ancora oggi i l’ora è divisa in 60 minuti, un minuto in 60 secondi…
Il comune sistema decimale che tutti impariamo a scuola, è, invece, di tipo posizionale: ogni cifra assume un significato diverso a seconda della posizione in cui si
trova (unità, decine, centinaia, ecc.).
Questo sistema deriva dagli Indiani che usavano un sistema di scrittura posizionale con 9 cifre, e al posto dello zero lasciavano uno spazio vuoto.
Gli Arabi appresero dagli indiani questo sistema e lo perfezionarono aggiungendovi lo zero, più comodo dello spazio vuoto.
(Vedi anche Da Wikipedia, l'enciclopedia libera )
Quindi, come rappresentare un numero naturale ? Attraverso una rappresentazione decimale posizionale.
Si utilizzano 10 cifre decimali (0, 1, ..., 9):
- la base è 10;
- posizionale: il significato di ogni cifra dipende dalla sua posizione relativa
- le posizioni si contano da destra a sinistra partendo da 0
ad es. 1919 = 1 × 103 + 9 × 102 + 1 × 101 + 9 × 100
In generale: numero di n cifre in base b:
an−1×bn−1+. . .+a1×b1+a0×b0
cifre usate: 0,1, . . . , b-1 ; a0 è la cifra meno significativa (LSD) ; an−1 `e la cifra pi`u significativa (MSD)
11 - Tecno1 rel. 17.03.17
Numerazione binaria
Il sistema numerico binario è usato in per la rappresentazione interna dei numeri, grazie alla semplicità di realizzare un elemento con due soli valori o stati, ma
anche per la corrispondenza con i valori di vero e falso. (Wikipedia)
Di fatto al posto di considerare le due mani con dieci dita si riduce ai minimi termini il calcolo sfruttando un solo dito: alzato o abbassato, di meno non è possibile!
Questo perché le macchine vengono costruite cercando il massimo della semplicità e facilità e quindi hanno bisogno di un linguaggio estremamente semplice e
povero.
Il sistema binario, ideato in origine dal matematico tedesco Leibniz, fu riscoperto nel da , che fornirà gli elementi matematici per la nascita del calcolatore
elettronico.
George Boole ( –) è stato un
e
, ed è considerato il fondatore della .
Nel pubblicò la sua opera più importante, indirizzata alle leggi del pensiero, dopo aver rilevate le analogie fra oggetti
dell'algebra e oggetti della logica, ricondusse le composizioni degli enunciati a semplici operazioni algebriche. Con
questo lavoro fondò la teoria di quelle che attualmente vengono dette
(o, semplicemente, ).
Tale algebra permette di definire gli AND, OR e NOT, la cui combinazione permette di sviluppare qualsiasi funzione logica
e consente di trattare le operazioni insiemistiche dell', dell' e della complementazione, oltre a questioni riguardanti
singoli 0 e 1, , e diverse altre funzioni binarie.
Il sistema numerico binario è un posizionale in base 2, cioè che utilizza 2 simboli, tipicamente 0 e 1, invece dei dieci (0,1,2..9) del sistema numerico decimale
tradizionale. Di conseguenza, la cifra in posizione N (da destra) si considera moltiplicata per 2^N (anziché per 10^N come avverrebbe nella numerazione
decimale).
Con n bit, si possono rappresentare, in binario, tutti gli interi da 0 a (2 n –1):
con un solo bit posso avere 0 e 1, con due bit posso rappresentare i numeri da 0 a 3: : 00, 01, 10, 11 ; con 3 bit 0 1 2 3 4 5 6 7 : 000, 001, 010, 011, 100, 101, 110,
111 e così via.
(approfondimento in )
Conversione binario-decimale-binario
Binario -> Decimale
La formula per convertire un numero da binario a decimale (dove con d si indica la cifra di posizione n all'interno del numero, partendo da 0) è:
d(n - 1)2(n - 1) + ... + d020 = N
Ad esempio
10012 = 1 * 23 + 0 * 22 + 0 * 21 + 1 * 20 = 910
Decimale-> Binario
Per convertire da decimale a binario, la parte intera, occorre procedere per divisioni successive per 2. Il resto costituisce una cifra del numero binario da destra
verso sinistra , dalla meno significativa (LSD) alla più significativa (MSD). Il procedimento si ferma quando il risultato è 1 che costituisce la cifra più significativa
Esempi di conversione Decimale-Binario:
37:2 = 18:2 = 9:2 = 4:2 = 2:2 = 1
1
0 1
0
0
Quindi partendo da destra a sinistra otterremo: 3710 => 1001012
15: 2 = 7:2 = 3:2 = 1
1
1
1
1510 => 11112
16: 2 = 8:2 = 4:2 = 2:2 = 1
1610 => 100002
12 - Tecno1 rel. 17.03.17
0
0
0
0
1310 = 11012
Infatti:
13 : 2 = 6 : 2 = 3 : 2 = 1
1
0
1
6310 = 1111112
Infatti:
63 : 2 = 31 : 2 =15 : 2 = 7 : 2 = 3 : 2 = 1
1
1
1
1
1
31:2....
32
63
64
128
Conversioni
Planetcalc
gioco didattico di CISCO, , in cui
tramite conversioni binario-decimale
si gioca a una specie di Tetris a livelli
Possono aiutare anche le carte binarie scientifica in Windows
di complessità crescente. (scaricabile
anche su ipad)
Altri
giochi:
)
e
calcolo
binario
Calcolatrice
Numerazione esadecimale
Il sistema numerico esadecimale (spesso abbreviato con hex o H) è un in base 16, cioè che utilizza 16 simboli invece dei 10 del tradizionale. Per l'esadecimale si
usano simboli da 0 a 9 e poi le lettere da A a F, per un totale di 16 simboli.
Ecco una tabella che confronta le rappresentazioni binarie, (in base 16) e di alcuni numeri:
bin
hex
dec
0000
0
0
0001
1
1
0010
2
2
0011
3
3
0100
4
4
0101
5
5
0110
6
6
0111
7
7
1000
8
8
1001
9
9
1010
A
10
1011
B
11
1100
C
12
1101
D
13
1110
E
14
1111
F
15
-----------------------------------10000
10
16
10001
11
17
……
Conversione decimale-esadecimale-decimale
Per le conversioni decimale-esadecimale il procedimento è analogo a quello in base 2 con la differenza che si deve procedere per divisioni successive per 16,
13 - Tecno1 rel. 17.03.17
anziché 2.
Ad esempio:
18:16=1 18d -> 12H
2
160:16=10
0
160d -> A0H
Per le conversioni esadecimale-decimale il procedimento è analogo a quello in base 2 con la differenza che si deve procedere sommando i prodotti di ciascuna
cifra per una potenza di 16
Ad esempio:
12H -> 2*16^0 + 1*16^1 = 2+16 = 18
A0H -> 0*16^0 + 10 *16^1 = 0+ 160 = 160
ABCH-> 2748 -> 101010111100
Conversione binario-esadecimale-binario
Binario-esadecimale. Prendiamo, ad esempio, il numero binario 10000000101 (corrispondente al decimale 1029). Essendo il sistema esadecimale basato sul
numero 16 (24) lo scriveremo raggruppando le cifre 4 a 4, partendo dalla posizione meno significativa, ovvero quella più a destra: 100 0000 0101
ogni raggruppamento corrisponde ad una cifra esadecimale secondo la tabella precedente.
Otterremo, quindi, trasformando i tre raggruppamenti, le tre cifre 4|0|5 corrispondenti al numero esadecimale 405H
Per la conversione esadecimale binario si procede esattamente al contrario:
consideriamo ancora il numero 405H e separiamolo in cifre come prima:
4|0|5 -> 100 0000 0101
Completare la seguente tabella
decimale
binario
326
11001101
127
129
128
111
111
esadecimale
111
10A
10000001
11111111
10000000
11111100
01000000
00010001
240
241
12B0C
FFFF
Rappresentazione di numeri interi
Come per i naturali, anche l’insieme dei numeri interi è infinito. I numeri interi rappresentabili con un numero finito di bit, sono solo un sottoinsieme finito dei
numeri interi. L’intervallo dei valori rappresentabili dipende dal numero di bit a disposizione. Con n bit possono essere rappresentati 2 n numeri.
Somma binaria
0+0 =0
1+0=1
0+1=1
1+1=0 con riporto di 1
14 - Tecno1 rel. 17.03.17
Riporto:
111100
011100+
100111 =
----------1000011
Riporto: 1000011
1010011 +
1100011 =
----------10110110
1001+
0001 =
_________
1010
Somma in esadecimale
La somma di due numeri esadecimali viene calcolata adattando le stesse regole della somma dei numeri decimali:
Si ha un riporto in esadecimale se la somma in qualunque posizione è maggiore di F.
Per esempio: A3DH + CA5H . Sommiamo ciascuna coppia di cifre. Ad esempio D+5 = 2, con riporto di 1 . Il riporto viene sommato alle cifre della colonna
immediatamente a sinistra. Cioè: A+3+1=E con nessun riporto
riporto
1
0
1
0
A
3
D
C
A
5
---------------------------------------------1
6
E
2
1AFH + 21H
Nella colonna più a destra la somma è F+1. Questa origina come bit somma 0 e come riporto 1. Cioè F +1=10. (F=15 ---> F+1= 15+1=16 ---> = 10H)
Il riporto viene sommato alle cifre della colonna immediatamente a sinistra.
Cioè A+2 +1. La somma di tale colonna origina come cifra somma D e nessun riporto. Il risultato alla fine sarà dunque 1D0H
18316 + 1216 =
154216 + BC116 =
ABC16 + F416 =
Modulo e segno
Per quanto riguarda la sottrazione, le regole sono simili (con la variante che 0-1=1 con prestito di 1), ma, per quanto possa sembrare strano i computer sono in
grado solo di effettuare somme e non sottrazioni. La sottrazione si ottiene sommando algebricamente, cioè addizionando un numero negativo, ad esempio 3-2
equivale a 3+(-2) .
Il problema è allora rappresentare un numero negativo in binario. Vediamo cosa significa.
Con n bit possono essere rappresentati 2 n numeri: metà positivi e metà negativi. Il problema allora è quello di distinguere tra positivi e negativi.
Un modo è quello di interpretare il bit più significativo con segno (1 se negativo, 0 altrimenti) e i rimanenti (n-1) bit per la rappresentazione del modulo. In
modulo e segno posso rappresentare su n bit i numeri da – (2 (n-1) – 1)  + (2 (n-1) – 1)
ES con 8 bit, - 54 : 10110110
Per comprendere meglio, usiamo un comodo strumento: “l’orologio binario”. Consideriamo per comodità quattro bit:
15 - Tecno1 rel. 17.03.17
orologio binario
NON
usato
Questa tecnica però NON viene usata perché ci sono problemi che rendono difficile l’utilizzo: ci sono due rappresentazioni dello zero ( 0000, 1000 ) e difficoltà
nelle operazioni di somma (quando i segni sono diversi). Al suo posto viene usato il “complemento a 2”.
Complemento a 2
E’ il metodo più usato per la rappresentazione dei numeri interi su n bit.
Si definisce complemento a 2 di un numero A, su n bit, il numero:
Ā = 2n – A
Ad esempio:
se A=3, il complemento a 2 su 4 bit è Ā=13, infatti: 2^4 – 3 = 16-3 =13
Con questa convenzione con n bit possono essere rappresentabili tutti gli interi tra:
– 2n-1  + (2 (n-1) – 1)
Ad esempio con n=8 (8bit) si avrà un range che va da -128 (10000000, pari a -28-1 ), fino a +127 (01111111, pari a +27-1)
Per comprendere meglio il complemento a 2 di un numero e la sua importanza applicativa, usiamo “l’orologio binario”. Consideriamo per comodità quattro bit:
orologio binario su 4 bit, in complemento a 2


Il numero 0 è rappresentato con 0000, 1 con 0001, -1 è 1111, -2 è 1110 e cosi’ via.
In particolare 7 (0111) è il piu’ grande numero positivo e –8 (1000) il piu’ grande , in modulo, negativo.
Si può notare che esiste un’ unica rappresentazione dello 0 e che gli interi codificati in complemento a 2 hanno il bit più significativo a 0 se sono positivi, 1 se
negativi.

Se consideriamo 8 bit, e non solo 4 come precedentemente descritto, si avrà che il numero 0 è rappresentato da 00h , 1 è 01h , 127 è 7Fh , -128 è 80h, -1 è
FFh (255). Il range va da -128 (10000000) a +127 (01111111)

Con 16 bit il numero 0 è 0000h , 1 è 0001h , 32767 è 7FFh , -32768 è 8000h, -1 è FFFFh (65535).
Il complemento del complemento restituisce il valore originale.
Operativamente, il complemento a 2 di un numero negativo –N si calcola così:
- si complementano i bit della rappresentazione binaria del modulo N del numero (cioè gli 1 diventano 0 e gli 0 diventano 1)
16 - Tecno1 rel. 17.03.17
- si somma 1 al risultato ottenuto
Esempio
-2 (su 4 bit) si ottiene cosi’:
si parte da 2 = 0010, lo si complementa a uno: 1101 a cui va sommato 1 :
1101+
0001=
-------------1110 => -2
Per fare un altro esempio -12 (su 5 bit) si ottiene così:
− 1210 = − 011002 = 10100CA2
Attenzione al numero di cifre da usare: ad esempio se utilizziamo 4 bit possiamo convertire al massimo il numero 7 (0111 con il bit più
significativo che deve essere a 0). Infatti se volessimo convertire su 4 bit il numero 9 (1001) otterremmo 0111. Al contrario, su 5 bit, avremo 01001-> 10111 che è
effettivamente -9.
Con 8 bit 11110111 e così via.
Dobbiamo anche tener presente che la somma di due numeri positivi potrebbe dare un numero negativo (ad esempio 5+4, su 4 bit, 1001 cioè -7). Il calcolatore
segnala questa eventualità tramite l’uso di flag (carry e overflow). Sarà il programmatore che deciderà come interpretare il risultato.
Sottrazione binaria in complemento a 2
La
definizione
di
complemento
B-A = B + (bn – A ) – bn = B + Ā - bn
a
2
è
=>
utile
perché
permette
di
ricondurre
sempre
le
sottrazioni
ad
addizioni.
Infatti:
B – A = B + Ā poiché su n bit bn = 0
Vengono enormemente facilitate le operazioni di somma e differenza, che si riducono alla sola operazione di somma: la differenza è la somma con il numero da
sottrarre complementato a 2!
ad esempio 5-3 = 5+ (-3) =2
Tramite il complemento a due una sottrazione è eseguita come un'addizione. Il riporto è trascurato.
Si parte da 3 = 0011, lo si complementa a uno: 1100, a cui va sommato 1 ottenendo il complemento a due: 1101:
5-
0101 -
3=
=>
0011=
0101 +
=>
1101 =
-----
----------
2
0010




5 - 8 (su 5bit) => 5 + (-8) = 001012 - 010002 = 001012 - 11000 CA2= 11101= − 3 (infatti 11101CA2 =>0011)
5 − 12 (su 5bit) => 5+ (− 12) = 001012 − 011002 = 00101+ 10100CA2 = 1001CA2= − 7
5 -10 (su 5bit) = 5+ (-10) => 00101 – 01010 = 00101+ (10101 +1 = 10110) => 00101 + 10110 = 1011= - 5
9 – 1 (su 4bit) = 9 + (-1) => 1001 – 0001 = 1001 + 1111 = 1000 (con riporto 1 che , se su 4 bit , ignoro)
Eseguire le seguenti operazioni (su 8 bit)
000111102 – 000000102 = 00011110 – 00000010 = 00011110 + (11111101 + 1) = 00011110 + 11111110= 11111100 = 28 10
111100102 + 000001102 =
001001112 + 000110102 =
111011102 + 000011012=
001110112 – 000001112 =
000100102 – 000001012 =
17 - Tecno1 rel. 17.03.17
Rappresentazione dei numeri reali
Finora ci siamo limitati ai numeri interi ma cosa capita per i numeri reali?
L’insieme dei numeri reali è un insieme infinito: presi due reali qualsiasi, esistono infiniti numeri reali compresi tra essi.
N.B. I numeri reali rappresentabili su n bit sono solo un sottoinsieme finito. Ciò significa che si possono rappresentare solo i numeri all’interno di un
certo intervallo e che anche all’interno dell’intervallo esistono dei numeri non rappresentabili.
Esistono due metodi utilizzati per rappresentare i numeri reali su un calcolatore:
• la rappresentazione in virgola fissa (FIXED POINT)
• la rappresentazione in virgola mobile (FLOATING POINT)
Rappresentazione in virgola fissa
Il metodo più semplice per rappresentare numeri frazionari è quello di scegliere dove posizionare, in modo prefissato (fixed point), la virgola all’interno del
numero. Ad esempio se si sceglie di usare 5 bit per la parte intera e 4 per la parte frazionaria si ottiene:
10101.11012 che rappresenta:
1*2 ^4 + 1*2 ^2 + 1*2^ 0 + 1*2^ -1 + 1*2^ -2 + 1*2 ^-4 = 21.8125
Aiutiamoci con questa tabella di conversione:
n
2^n
2^-n
0
1
1.0
1
2
0.5
2
4
0.25
3
8
0.125
4
16
0.625
5
…
..
Parte frazionaria binaria
0
1
01
001
0001
..
Ad esempio, consideriamo il numero 011011.11. Il numero è rappresentato con 8 bit, di cui i primi 6 per la codifica della parte intera, e gli ultimi 2 bit per quella
frazionaria. La sequenza 01101111 rappresenta il numero frazionario binario: 011011.11 = 27.75.
Il numero binario frazionario 0.11 viene rappresentato in virgola fissa con 00000011 (=0.75)
Calcolare a quale numero decimale corrispondono i seguenti numeri binari frazionari:
• 0.1101001 [R. 0.8203125]
• 1011.0101 [R. 11.3125]
• 11.10011 [R. 3.59375]
Conversione Decimale->Binario di numeri frazionari in virgola
fissa
La conversione da sistema decimale a sistema binario in virgola fissa, in cui si impiegano m bit per rappresentare la parte intera ed n bit per rappresentare quella
frazionaria si esegue con il seguente algoritmo ( ):
1.si considerano separatamente parte intera e parte frazionaria;
2.la parte intera viene convertita in un numero binario a m bit;
3.la parte frazionaria viene convertita in un numero binario a n bit effettuando moltiplicazioni successive per 2 separando la parte intera (0 od 1) da quella
frazionaria così ottenuta, finché:
o
si ottiene parte frazionaria nulla
o
oppure si sono ricavati tutti gli n bit disponibili per la rappresentazione in virgola fissa.
In questo caso la rappresentazione del sistema binario è un’ approssimazione di quella nel sistema decimale.
Esempio di conversione
37,125= 100101.001 infatti:

separo 37 da 0.125;

la parte intera la rappresento come 100101
18 - Tecno1 rel. 17.03.17

per quanto riguarda la parte frazionaria eseguo iterative moltiplicazioni per 2:
0,125x2 =>0,25 (primo bit dopo la virgola),
0,25x2 =>0,5
0.5x2
=>1,0
0
 termino perché la parte dopo la virgola è 0.
la parte frazionaria la rappresento come
001
Consideriamo ora il numero decimale 0,3= 01001
0.3 x 2 = 0.6 => bit 0
0.6 x 2 = 1.2 => bit 1
0.2 x 2 = 0.4 => bit 0
0.4 x 2 = 0.8 => bit 0
0.8 x 2 = 1.6 => bit 1
0.6 x 2 = 1.2 => bit 1
0.2 x2 = 0.4 => bit 0
04x2=…..
In generale il procedimento potrebbe terminare dopo molte cifre o non terminare mai! E’ necessario perciò approssimare il numero trovato, fermandosi dopo un
numero di passi predefinito. Del resto il numero di bit nella memoria di un computer è limitato.
Ad esempio:
Convertire in binario il numero 0.3 con un errore di rappresentazione inferiore a 0.01
0.3 x 2 = 0.6 => bit 0 [peso 0.5]
0.6 x 2 = 1.2 => bit 1 [peso 0.25]
0.2 x 2 = 0.4 => bit 0 [peso 0.125]
0.4 x 2 = 0.8 => bit 0 [peso 0.0625]
0.8 x 2 = 1.6 => bit 1 [peso 0.03125]
0.6 x 2 = 1.2 => bit 1 [peso 0.015625]
0.2 x 2 = 0.4 => bit 0 [peso 0.0078125] < 0.01: ho raggiunto la precisione desiderata.
(
)
6.25= 110.01
Convertire in binario il numero
separo 6 da 0.25;
la parte intera la rappresento come 110
per quanto riguarda la parte frazionaria eseguo iterative moltiplicazioni per 2->
1.25 2 = 0.5x 2
0.5x 2 = 1.0 FINE!
Convertire in binario i seguenti numeri:
• 0.625 [R. 0.101] 0.625x2=1.25x2=0,5x2= 1,0
• 0.03125 [R. 0.00001]
• 0.828125 [R. 0.110101]
Rappresentazione in virgola mobile (floating point- IEEE754)
Lo standard IEEE754 definisce un metodo per la rappresentazione dei numeri in virgola mobile
Rappresentare il numero in binario
- Trasformare il numero in notazione esponenziale normalizzata in cui 00...002 rappresenta il valore 0; la rappresentazione degli altri numeri usa il seguente
formato:
(-1)s × (1 + MANTISSA) × 2e
Precisione singola
4 byte-> 1 bit per il segno, 8 bit per l’esponente, 23 bit per la mantissa
Il numero di bit della mantissa rappresenta il numero di cifre significative, cioè dà la precisione del numero. La cifra 1 prima della virgola è sottintesa e quindi si
hanno 23 bit interamente dedicati alla mantissa (6,7 cifre decimali):



per primo c’è il segno per vedere se si tratta di numeri positivi o negativi
l’esponente è indicato prima della mantissa (numeri con esponente più grande sono più grandi, indipendentemente dalla mantissa)
Per la rappresentazione dell’esponente viene usato un metodo particolare (esponente biased). L’esponente viene rappresentato nella forma bias + E
19 - Tecno1 rel. 17.03.17



dove bias = 2n/2 –1 (dove n è il numero di bit per l’esponente)
Il numero di bit riservati all’esponente determina l’intervallo dei numeri ammessi o ordine di grandezza.
Il numero di bit riservati alla mantissa determina il numero di cifre significative che si possono usare, cioè la precisione
La cifra 1 prima del punto decimale viene sottintesa.
Se n=8 bit si avrà bias= (2^8/2) – 1 = (256/2) -1 = 127
Questa notazione è adatta per le operazioni di confronto tra numeri.
Nell’esempio che segue si ha: 0 10000111 10110000000000000000000
segno=0 => numero positivo (1 rappresenta un numero negativo)
10000111 => 135
esponente eccesso 127 => 135-127=8 =>2^8
mantissa => 10110.. è da intendersi sempre come 1.10110..
 In definitiva il numero binario rappresenta: 1.1011 x 2^8 = 11011 x 2^4= 11011 x 16 = 27x16= 432
0 10000101 00110100000000000000000
segno=0 => numero positivo
esponente eccesso 127 => 133-127=6 =>2^6
mantissa => 0011010..
In definitiva: 1.001101 x 2^6 =77
Precisione doppia

8 byte: 1 bit per il segno, 11 bit per l’esponente, 52 per la mantissa
La cifra 1 prima della virgola è sottintesa e quindi si hanno 53 bit interamente dedicati alla mantissa (15,16 cifre decimali).
0 10000001 010010 … 0
1 10001101 01110 … 0
0 01111101 01010 … 0
[R. 5.125]
[R. –23552.0]
[R. 0.328125]
Conversione decimale –> floating point
13.25
- il numero è positivo, per cui il segno è 0
- in binario: 1101.01
- spostando il punto decimale di 3 posizioni a sinistra, il numero si normalizza in 1.10101 x 2^3
- l'esponente (eccesso 127 ): 127 + 3 = 130 = 10000010
Quindi in Floating Point, singola precisione:
0
10000010
10101000000000000000000
segno positivo
esponente eccesso 127
mantissa
-109,78125 = 1 10000101 10110111010000000000000
infatti:
109 = 1101101
1101101,11001 che in notazione normalizzata corrisponde a: 1,1011011001x2^6.
All’esponente va aggiunto 127 + 6 =133 (10000101) .
Quindi in Floating Point, singola precisione:
1
10000101
10110110010000000000000
segno negativo
esponente eccesso 127
mantissa
5.0 [R. 0 10000001 0100 … 0]
-9.25 [R. 1 10000010 0010100 … 0]
12.8125 [R. 0 10000010 100110100 … 0]
Operazioni con la rappresentazione floating point
 Si possono sommare du enumeri floating point solo se hanno lo stesso esponente
Se gli esponenti non sono uguali bisogna trasformare il numero con esponente più grande per rendere l’esponente uguale a quello dell’altro numero; in tal caso il
20 - Tecno1 rel. 17.03.17
numero è in forma non normalizzata; il risultato deve poi essere normalizzato
 Per eseguire la moltiplicazione si moltiplicano le mantisse e si sommano gli esponenti (perché la base è la stessa); il prodotto è in forma non normalizzata e
aumenta il numero di cifre, quindi deve essere arrotondato
Ecco una tabella che riporta in modo schematico le principali classi di valori, numerici e speciali, rappresentabili nello standard aritmetico in virgola mobile IEEE
754.
Singola precisione
Doppia precisione
Entità rappresentata
Parte frazionaria
Parte frazionaria
Esponente (o mantissa)
Esponente (o mantissa)
0
0
0
0
0
0
≠0
0
≠0
Numero denormalizzato
da 1 a 254 valore qualsiasi da 1 a 2046 valore qualsiasi Numero in virgola mobile
255
0
2047
0
∞
255
≠0
2047
≠0
NaN (Not a Number)
Tipi di dati in C
Il tipo di un dato è l’astrazione della sua rappresentazione.
Tipo
Dimensione
Intervallo di valori
Char
1 byte
0 / 255
Int (short int)
2 byte
- 32768 / 32767
Long
4 byte
- 2147483648 / 2147483647
Unsigned int
2 byte
0 / 65535
Unsigned long
4 byte
0 / 4294967295
Float
4 byte
Notazione IEEE standard
double
8 byte
Notazione IEEE standard
(big endian-little endian)
Proprietà dell’aritmetica in virgola mobile
Questa aritmetica presenta due fondamentali differenze dall'aritmetica reale:

l'aritmetica in virgola mobile non è : in generale, per i numeri in virgola mobile,
;

l'aritmetica in virgola mobile non è :in generale,
.
In definitiva, l'ordine in cui vengono eseguite più operazioni in virgola mobile può variarne il risultato. Questo è importante per l'analisi numerica, in quanto due
formule matematicamente equivalenti possono dare risultati diversi, uno anche sensibilmente più accurato dell'altro. Per esempio, nella maggior parte delle
applicazioni in virgola mobile, 1,0 + (10100 + -10100) dà come risultato 1,0, mentre (1,0 + 10100) + -10100 dà 0,0.
La virgola mobile appare più appropriata quando si richiede una certa precisione relativa al valore. Quando è richiesta una precisione assoluta, la virgola fissa
sembra una scelta migliore.
21 - Tecno1 rel. 17.03.17
BCD
Il codice BDC (Binary Code Decimal) viene usato per la rappresentazione di numeri che possano essere convertiti rapidamente in cifre decimali
In ogni byte vengono rappresentate due cifre decimali; ogni cifra del numero decimale occupa 4 bit, che assumono il valore della corrispondente
rappresentazione binaria.
Cifra decimale
0
1
2
3
4
5
6
7
8
9
Codice BCD
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
Con 4 bit le configurazioni possibili sono 16 ma per rappresentare le cifre da 0 a 9 ne vengono usate solo 10; ne restano 6 inutilizzate, cioè il codice è ridondante.
Per rappresentare un numero decimale con il codice BCD servono più bit rispetto alla rappresentazione in sistema binario.


Il fatto che il codice sia ridondante influenza anche le operazioni aritmetiche, infatti per ottenere risultati corretti bisogna seguire le seguenti regole:
se sommando due cifre BCD si ottiene come risultato una combinazione non lecita bisogna sommare 6 perché le combinazioni illecite sono 6.
Se nel risultato della somma di due cifre BCD si verifica un riporto bisogna sommare 6.
0001 1000 0111 +
0101 0011 1001 =
_________________
0110 1100 0000 +
0110 0110
_________________
0111 0010 0110
(520)10 + (150)10
0101
0010
0001
0101
0110
0111
0000
0000
0000
520 +
150 =
670
Esercizi di riepilogo:
1 Rappresentare i seguenti numeri in complemento a 2 su 8 bit:
127 -127 -128 128 0 1 -1 256 -256
2 Rappresentare i seguenti numeri in complemento a 2 su 8 bit:
44 -44 127 -127 -128 128 0 1 -1 256 -256 -53 -75
3 Data la rappresentazione in complemento a 2 (su 8 bit), quali numeri sono rappresentati?
11010100
11100101 01111111 10000000
3 Dare la rappresentazione come numeri interi a 16 bit dei numeri 68 e 20 ed eseguire 68-20 con il metodo del complemento a 2.
4 Eseguire le seguenti sottrazioni usando il complemento a 2 su 8 bit
31-32
32-33
64-68
64-4
4.1 Eseguire le seguenti sottrazioni usando il complemento a 2 su 16 bit
123-43
32-54
45-67
176-24
5 Rappresentare con il codice BCD i numeri 2706
187
6 Eseguire la somma dei seguenti codici BCD e dire a quali numeri corrispondono operandi e risultato
00101001 + 00011000 =
7 Rappresentare 35,24 secondo lo standard IEEE754
8 Data la seguente rappresentazione (IEEE754), 01000010011010000000000000000000
9 Dare le rappresentazione di 327 come numero intero a 16 bit, con il codice BCD, come numero reale secondo lo standard IEEE754
10 rappresentare 62,15
0,125
45,25
67 secondo IEEE754
22 - Tecno1 rel. 17.03.17
Comunicazione e Codici
COMUNICAZIONE = Fenomeno in virtu' del quale l'uomo si relaziona dal punto di vista: Informativo, Esplorativo, Partecipativo con altri uomini e il cosmo
E’ tramite la comunicazione e lo scambio di informazioni che le civiltà umane si sono evolute e sviluppate. Prima attraverso il comportamento, i gesti e la danza,
poi con il linguaggio e con le immagini, quindi con la scrittura, con il modo di vestirsi, con i messaggi sonori e di fumo, incidendo piante e rocce, costruendo torri,
mandando segnali luminosi, elettrici, magnetici …. Ma anche viaggiando, navigando, commerciando e, purtroppo, talvolta, invadendo e facendo la guerra…
A noi interessa l'aspetto INFORMATIVO: scambio di informazioni da un soggetto a un altro per mezzo di veicoli di varia natura, usando una Sorgente,
un'Emittente (trasmettitore), un messaggio e un segnale , un canale, un rumore, un ricevente e un destinatario.
Schema fondamentale della comunicazione.
Immaginiamo che in un bacino idrico sia necessario segnalare a distanza quando il livello dell'acqua è entro misure di sicurezza e quando invece diventa
pericoloso.
Possiamo utilizzare il seguente sistema comunicativo:
quando si ha la situazione ”acque a livello pericoloso" (referente), un galleggiante (sorgente) chiude l'interruttore di un circuito elettrico (produttore) in modo che
la chiusura del contatto (trasmettitore) invii il messaggio sottoforma di corrente elettrica (segnale) attraverso il filo (canale), strettamente legato alla natura del
segnale che deve far transitare.
Il segnale giunge a una lampada (il ricevitore) che si accende. Il sorvegliante (destinatario), recepito il messaggio, capisce, dal contesto, il messaggio e si rende
conto che le acque sono a un “livello pericoloso.
Può capitare che, pur essendo le acque a livello di sicurezza, un contatto lungo il filo o altro elemento esterno producano un passaggio di corrente nel circuito e lo
chiudano accendendo la lampada; oppure che, con le acque a livello di pericolo, dei contatti difettosi non permettano alla corrente di raggiungere la lampadina:
avremo delle interferenze nel canale o dei fenomeni di rumore.
Questo modello può essere tradotto schematicamente cosi’:

Referente (Contesto)

Sorgente/Produttore

Trasmettitore/Codificatore (contatto elettrico) , traduce messaggio in segnale con il codice : corrente ON/OFF

Canale (con rumore)

ricevitore/decodificatore

Destinatario
Torniamo ora al nostro modello per il bacino idrico.
Abbiamo qui un codice a solo due sole unità: "luce spenta" (= "a livello sicuro") e “luce accesa" ("acque a livello di pericolo").
Proviamo ora a immaginare un codice un poco più complicato, nel quale alle unità "luce spenta" e "luce accesa" vengano sostituite rispettivamente le unità "luce
accesa bianca" e "luce accesa rossa".
Quali sono le differenze tra il primo codice (A) e il secondo codice (B)? ll primo è più semplice e meno costoso e si fonda sulla contrapposizione fra assenza e
presenza di luce. Sono possibili due segni o messaggi distinti.
Un codice di questo tipo obbedisce a un principio di minimo sforzo e di economicità.
Il codice B è più complesso e costoso; per realizzarlo sono necessarie due lampadine di colore diverso e due canali; il destinatario deve saper distinguere fra due
luci diverse.
Se però badiamo ai possibili effetti del rumore sui due codici, notiamo che il codice B ha dei vantaggi sul codice A.
Nel caso di A l'effetto del rumore (immissione o interruzione non prevista di corrente è di trasmettere comunque un messaggio; esso può risultare erroneo al
23 - Tecno1 rel. 17.03.17
produttore, ma il destinatario non é in grado di distinguerne l'erroneità; un qualsiasi contatto fa scattare l'allarme, anche se le acque sono a livello di sicurezza.
Nel caso B a principio di economicità (una sola lampadina), si sostituisce il principio di ridondanza (due lampadine). Tale ridondanza ha una funzione. In caso di
contatto (rumore> lo spegnersi o l'accendersi della luce non è previsto dal codice e non trasmette nessun messaggio e quando avviene non induce in errore il
destinatario che, come il produttore, si accorge soltanto che qualcosa non va nell'impianto.
La ridondanza quindi funziona da correzione degli errori possibili nella trasmissione di un messaggio.
La ridondanza ha anche un'altra funzione: permette al codice di produrre ulteriori messaggi per nuove esigenze che possano sorgere.
Se, per es., nel bacino idrico risultasse necessario introdurre un nuovo messaggio per segnalare un livello intermedio delle acque (livello di preallarme), il codice
A non potrebbe trasmettere tre diversi messaggi distinti e l'intero impianto dovrebbe essere cambiato; il codice B invece può trasmettere un terzo messaggio
(per es. accensione contemporanea di tutte e due le lampadine). La ridondanza quindi consente a un codice di adattarsi a nuove situazioni e di resistere nel
tempo.
Quando due entità, persone, macchine, cose, comunicano tra di loro attuano dei meccanismi che Shannon e Weaver, nel 1948-49 hanno studiato e codificato
nella “Teoria Matematica della Comunicazione”.
La comunicazione è vista come «trasmissione di un’informazione attraverso un messaggio
inviato da un emittente a un ricevente».
schema della comunicazione di Shannon





La sorgente/produttore dell’informazione crea il messaggio
Il trasmettitore/codificatore, ricevute le informazioni, le traduce in messaggio da trasmettere lungo il canale
Il canale, che funge da mezzo di trasmissione del segnale provvede a trasmetterlo a destinazione
Il ricevitore/decodificatore, riceve il segnale trasmesso lungo in canale e provvede a decodificarlo.
Il destinatario (persona o macchina), che riceve il messaggio e ne comprende il significato in funzione di un “contesto” comune al produttore
(“referente”)
Dato un PRODUTTORE e un DESTINATARIO, il MESSAGGIO che passa dall'uno all'altro è un ATTO DI COMUNICAZIONE.
Il messaggio prodotto da una sorgente viene codificato da un trasmettitore e utilizza un canale (per es. il filo telefonico la carta stampata, ecc.) per essere
inviato al ricevitore che lo decodifica per il destinatario, che lo riceve correttamente se non si hanno fenomeni di rumore (interferenze nel canale, interruzioni o
disturbi del processo della comunicazione). Il messaggio che, trasmesso in codice mpassa dal produttore al destinatario, fa riferimento a un preciso contesto.
Cos'è esattamente il contesto? E' ciò che circonda il produttore e il destinatario; è il mondo, la realtà, il complesso di idee che essi hanno in comune.
Il CODICE è il sistema delle regole in base al quale il messaggio è strutturato. Esso è costituito da un insieme di simboli (alfabeto) e dalle combinazioni di simboli
validi (parole).
“Un codice è un modo per rappresentare un insieme di informazioni di differente complessità. La codifica permette di associare a ciascuna entità informativa un
riferimento univoco, detto codice, rappresentato in genere tramite stringhe o simbologie specifiche” (da Wikipedia - definizione di Codice nella Teoria
dell'Informazione).
codici geroglifici
Per poter utilizzare un codice deve essere definito un processo di codifica che permette di rappresentare delle informazioni mediante un certo codice.
Per ogni processo di codifica è definito il processo inverso, o decodifica che permette di estrarre le informazioni da un messaggio codificato. Questo implica che
durante il processo di decodifica deve essere possibile distinguere una dall’altra le parole del codice, indipendentemente dalla sequenza con cui sono usate;
questa condizione è semplice da rispettare se le parole del codice hanno tutte la stessa lunghezza, cioè lo stesso numero di simboli. Ad esempio se codificassimo
le lettere A,B,C,D nel modo seguente: A=0, B=1, C=01, D=10, non sapremmo dire se 010 corrisponda a ABA, AD, CA.
In caso contrario occorre definire precisi schemi entro cui il messaggio viene inviato.
Si dice alfabeto un insieme non vuoto e finito di simboli detti caratteri. Ad esempio:

A = {0, 1} è l’alfabeto binario.

B = {A, B, C, . . . , X, Y, Z} è l’alfabeto delle lettere latine maiuscole.
Una stringa o parola in un dato alfabeto è una successione di simboli (anche ripetuti) di quell’alfabeto.
24 - Tecno1 rel. 17.03.17
“Dato un insieme I di oggetti, si dice codifica dell’insieme I nell’alfabeto L, un procedimento che permetta di stabilire una corrispondenza biunivoca fra gli
elementi di I e un sottoinsieme di parole di L. “
AD esempio Il codice Morse traduce le lettere in sequenze di punti e linee (quindi rappresentabile anche con segnali luminosi, sonori o elettrici). Ogni punto è
rappresentata da una unità di tempo (1/25 di secondo), ed ogni linea di 3 unità. Gli spazi tra le lettere sono di 3 punti, e fra le parole di 5.
(http://www.belloma.it/codici-e-macchine-lalfabeto-morse/)
Nell’utilizzo del computer tutti i codici usano come alfabeto le cifre del sistema binario 0 e 1.
L’uso di due soli simboli riduce la possibilità di errore (è più facile distinguere tra due valori che tra dieci) e rende semplice la rappresentazione all’interno del
computer, infatti due simboli possono essere rappresentati con due stati fisici distinti.
codice binario applicato ai caratteri di testo
L’interazione uomo-macchina
Un particolare tipo di comunicazione riguarda la comunicazione tra uomo e macchina.
L’interazione uomo-macchina è un campo di studi che si prefigge il compito di indagare il rapporto tra l’uomo e le tecnologie e di applicare i risultati della propria
indagine alla progettazione di sistemi per la comunicazione tra l’uomo e la macchina.
In modo sintetico, la comunicazione identifica uno scambio di messaggi tra due stazioni, emittente e ricevente, che condividono un codice. Lo schema di base
della comunicazione include una stazione di partenza, un canale e una stazione di arrivo. Il messaggio rappresenta il contenuto scambiato tra emittente e
ricevente.
Quando la comunicazione avviene tra l’essere umano e la macchina, l’interfaccia è l’elemento che veicola questa comunicazione e quindi l’interazione tra questi
due soggetti.
L’interazione uomo-macchina “si occupa della progettazione di sistemi che siano in grado di sostenere le persone che li usano a svolgere la loro attività in modo
produttivo e sicuro …”
L’interfaccia uomo-macchina è uno degli elementi caratterizzanti un sistema informatico. Infatti, ogni applicazione può essere classificata anche sulla base della
modalità con cui si presenta all’utente e, viceversa, grazie alla quale l’utente può interagire con l’applicazione. Questo elemento, solitamente indicato con il
nome interfaccia utente, racchiude quell’insieme di funzionalità di comunicazione in cui l’utente dell’applicazione può essere fonte o destinatario del messaggio.
A causa dei vincoli tecnologici, infatti, l’interazione uomo-macchina ha prediletto il senso della vista come canale di comunicazione. Attraverso la multimodalità si
offre una maggiore versatilità coinvolgendo altri sensi quali il tatto e l’udito e, nell’ultimo periodo, anche l’olfatto (sebbene ancora in fase pionieristica).
25 - Tecno1 rel. 17.03.17
Informazione
L’originalità dell’approccio di Shannon consistette nell’introdurre una misura dell’informazione «capace di definirne la quantità dalla sorgente al destinatario».
Shannon studia l’informazione «utilizzando una teoria matematica, basata sul calcolo delle probabilità, applicata a sistemi che si possono conoscere in modo
imperfetto»
L’informazione è ciò che aumenta il patrimonio conoscitivo. Può essere di varia natura: immagini (cartelli stradali, semaforo,..), luce (faro), suono (campanella),
numeri, parole, interruttori...
Consideriamo un interruttore: esso ha due possibili stati (o scelte) ON (1) , OFF (0).
A un interruttore è associata una sola informazione (2^1): acceso o spento, cioè l'informazione tra due messaggi alternativi è unitaria
A due interruttori sono associate 2 informazioni e 4 stati (2^2). Tre interruttori forniranno 3 informazioni con 8 stati (2^3), e… cosi' via.
La stessa cosa cosa possiamo dire se abbiamo due strade a un bivio: un’informazione. Se avessimo 4 diramazioni, avremmo 2 informazioni. Se avessimo un senso
unico NON avremmo alcuna (0) informazione (1=2^0).
NB attenzione all’esponente di 2 che è corrisponde al valore dell’informazione: 1,2,3,0 rispettivamente!
Tanto più ho possibilità di scelta tanto maggiore è la quantità di informazione. L’informazione è il numero di diversi messaggi che potrebbero essere trasmessi su
un canale in funzione del numero di scelte di simboli usati.
L'informazione è uguale al logaritmo in base 2 del numero di scelte equiprobabili e l'unità di misura dell'informazione è il bit
[bit]
Un bit non è altro che la quantità di informazione fornita dalla scelta fra due alternative diverse, considerate come egualmente probabili. (Il
termine bit corrisponde alla contrazione dell'inglese binary digit, numero binario).
Nel caso generale di n scelte possibili l'informazione verrà calcolata sostituendo al numero totale di scelte l'inverso della probabilità di scelta se P = 1/n°scelte, si
ha:
[bit]
Nel
caso
in
cui
le
scelte
possibili
non
siano
equiprobabili
bisogna
ricorrere
alla
formula
dell’
Entropia.
L'entropia si presenta come una sommatoria di tutte le informazioni che compongono il messaggio finale, pesate a seconda del numero di casi che esse
possiedono.
[
bit]
Ad esempio: H = 1/3log23 + 1/7log27 + 1/4log24 + 1/2log22 = 1,929372
Il valore così ottenuto rappresenta l'informazione necessaria per individuare una delle quattro destinazioni al primo livello.
Il concetto di quantità di informazione è associato alla possibilità di comprimere i dati mantenendo inalterato il, contenuto informativo (cfr codice di Huffman,
tecniche di compressione basate su gli studi di Lampel-Ziv, ecc).
«La mia più grande preoccupazione era come chiamarla. Pensavo di chiamarla informazione, ma la parola era fin troppo usata, così decisi di chiamarla incertezza.
Quando discussi della cosa con John Von Neumann, lui ebbe un'idea migliore. Mi disse che avrei dovuto chiamarla entropia, per due motivi: "Innanzitutto, la tua
funzione d'incertezza è già nota nella meccanica statistica con quel nome. In secondo luogo, e più significativamente, nessuno sa cosa sia con certezza l'entropia,
così in una discussione sarai sempre in vantaggio"» (Shannon)
Esercizi su informazione ed entropia
Esercizio 1. Qual è il contenuto informativo di una moneta "onesta"? log 2=1 (il log è in base 2) (2 scelte equiprobabili)
Esercizio 2. Qual è il contenuto informativo di un dado "onesto"?….... [2.58 ]
Esercizio 3. Qual è il contenuto informativo di una moneta truccata con probabilità 1/4 e 3/4 ?? H=.................................... [0.811 n.b. < 1 !!!]
Esercizio 4. Si supponga che la frequenza con cui le singole lettere vengono impiegate nella lingua italiana sia quella in tabella (ottenuta su u campione di 128
lettere). Quale è l'entropia? …..[4.19 ]
lettere frequenza
lettere
frequenza
A E I O 12
BDFG 4
CRST
7
PUV
4
LMN
6
HQZ
2
26 - Tecno1 rel. 17.03.17
Codici per la rilevazione e la correzione degli
errori
Come abbiamo visto nei paragrafi precedenti, quando inviamo dei dati su un canale di comunicazione i disturbi (rumore) possono corrompere i dati e far in modo
che il destinatario riceva trame contenenti degli errori.
Per rilevare e correggere gli errori di trasmissione si trasmettono, assieme ai dati utili, uno o più bit di ridondanza.
Al messaggio vengono, cioè, aggiunti dei bit di controllo. Particolari tecniche, applicate in trasmissione e ricezione, consentono di verificare che il messaggio
arrivato sia, ragionevolmete, corretto.
Le tecniche più semplici aggiungono alla fine del dato un controllo della parità. Altre, alla fine della trama di dati, aggiungono un campo contenente la
sommatoria dei dati trasmessi (checksum). Altre tecniche più sofisticate (CRC), trattano i bit trasmessi come polinomi numerici e calcolano il resto della divisione
tra questi polinomi e un divisore comune (polinomio generatore) .
Il CRC è usato comunemente nei protocolli moderni perché riduce la probabilità di non rilevare eventuali bit errati. Inoltre il CRC si adatta bene a correggere
errori a “burst”, cioè errori che danneggiano un insieme di bit consecutivi come capita, tipicamente, in caso canali di comunicazione soggetti a rumore.
Controllo di parità
Il controllo di parità, usato spesso nelle trasmissioni asincrone, è associato ad ogni carattere trasmesso. Esso può essere pari (EVEN) o dispari (ODD). Il calcolo
per la definizione del bit di parità viene fatto sempre sul numero di bit a 1 presenti nel carattere.
Quando la parità è pari il numero di bit a 1 compreso quello di parità deve essere pari, se invece la parità è dispari il numero dei bit a 1 deve essere dispari.
Come si può intuire, risulta impossibile rilevare l'errore quando esso si verifica su un numero pari di bit.
Si tratta di un controllo debole, usato per trasmissioni asincrone a bassa velocità e su brevi distanze. Al controllo di parità sul singolo carattere (Controllo a
ridondanza verticale(VCR)), è possibile associare un controllo sull’insieme dei caratteri trasmessi e (Controllo longitudinale (LCR) detto anche BCC (Block Check
Control) per rendere meno debole il risconoscimento dell’errore.
L’esempio sottostante illustra un caso in cui si usa sia VCR che LCR. La stringa inviata “CIAO”, è codificata in ASCII e risulta:
codifica carattere VCR (Parità pari)
C
01000011
1 -> Bit di controllo per un carattere
I
01001001
1
A
01000001
0
O
01001111
1
___________________________
LCR (BCC)
00000100
1
Si può notare come un controllo di “parità pari” corrisponda a un’operazione di OR esclusivo (XOR, Exclusive OR,
realizzazione di programmi software.
) tra i bit, una tecnica molto sfruttata nella
Controllo a somma aritmetica (checksum)
Consiste nel sommare il valore binario, corrispondente alla codifica ASCII dei caratteri, modulo 256.
Un esempio checksum su 16 bit:
Il vantaggio di tali calcoli di checksum è la dimensione fissa e la facilità di elaborazione.
Altre comuni varianti di questo semplice checksum sono ottenute usando al posto della somma l'operazione di XOR come nel Longitudinal redundancy check
(LRC).
NOTA sulla SICUREZZA
Questi metodi sono utili per la verifica di corruzioni accidentali (errori di trasferimento, o di memorizzazione, perdita di dati), ma non sono sicuri contro gli
27 - Tecno1 rel. 17.03.17
attacchi di malintenzionati, in quanto le loro strutture matematiche non sono particolarmente complesse da aggirare. Per questo tipo di attacchi vengono
utilizzati algoritmi di hash come l'MD5,lo SHA-256, per il momento incorruttibile (http://onlinemd5.com/) .
Controllo a ridondanza ciclica CRC (Ciclic Redundancy Check)
Il CRC consiste nel trasformare il messaggio da trasmettere in un polinomio con potenze di due. Ad esempio il messaggio 1011 può considerarsi uguale al
polinomio 2^3+2^1+2^0 o, altrimenti scritto: x3 + x + 1.
Il calcolo del CRC si basa sulle proprietà dell’aritmetica modulo 2, in cui non si hanno riporti né per somme né per sottrazioni e, di fatto, somme e sottrazioni sono
identiche e possono essere pensate come l’operazione di OR esclusivo, che restituisce 1 (vero) se e solo se uno solo dei due operandi è 1, mentre restituisce 0
(falso) in tutti gli altri casi.
La divisione in modulo 2 è analoga a quella decimale tradizionale, ma con l’oerazione di XOR al posto delle sottrazioni
Il polinomio corrispondente al messaggio da trasmettere viene diviso per un polinomio divisore (o polinomio generatore), noto a entrambe le stazioni collegate. Il
resto della divisione viene inviato assieme ai dati.
Il ricevente può effettuare il controllo in due modi, il primo è di dividere tutto il messaggio ricevuto compreso il resto della divisione e dividerlo per il polinomio
generatore, se il resto della divisione è 0 allora il messaggio è corretto. Il secondo modo è di eliminare il resto della divisione dai dati ricevuti e dividere
quest'ultimo per il polinomio generatore, se il resto ottenuto è uguale a quello tolto dai dati ricevuti, il messaggio è corretto.
Consideriamo il seguente esempio.
Messaggio da inviare = 1011100101 -> x9 + x7 + x6 + x5 + x2 + 1
Polinomio Generatore = 1011
-> x3 + x + 1
Per effettuare l’operazione si aggiungono al messaggio tanti bit a 0 quanto è il grado del polinomio divisore. Perciò:
Messaggio + 3 bit 0 = 1011100101000
Si procede alla divisione tra polinomi ricordando che la somma 1+1=0 allo stesso modo della funzione XOR. Si trascura il risultato e si considera solo il resto, che
viene aggiunto al messaggio e trasmesso al ricevitore:
1011100101000
1011
1011
1000101010
0001
0000
0010
0000
0100
0000
1001
1011
0100
0000
1001
1011
0100
0000
1000
1011
0110
0 0 0 0 = 110 Resto
Messaggio inviato al ricevitore = 1011100101110
Polinomi generatori
La selezione del polinomio generatore è importante: il polinomio deve essere scelto per rendere massima la possibilità di rilevamento di errori. A questo
proposito è determinate la lunghezza del polinomio (legata al suo grado). Ecco perché i polinomi più usati hanno un grado elevato. Ad esempio tra i più usati
nelle telecomunicazioni possiamo citare:
CRC12 = x12 + x11 + x3 + x2 + x + 1 (13bit) che tradotto in bit risulta: 1100000001011
CRC16 = x16 + x15 + x2 + 1 (17bit)
che tradotto in bit risulta: 11000000000000101
CRCCCITT = x16 + x12 + x5 + 1 (17bit)
che tradotto in bit risulta: 10001000000100001
Esiste anche un CRC-32 e CRC-64, rispettivamente a 33bit e 65bit.
Codifica dei caratteri alfanumerici
Una codifica per i caratteri è definita dalla corrispondenza tra l’insieme di caratteri che si vogliono rappresentare e le parole di un codice.
Nell’insieme dei caratteri si considerano almeno le lettere, le cifre e alcuni simboli. I diversi insiemi di caratteri sono definiti da standard ISO (International
Standards Organization).
Per un certo insieme di caratteri definito in uno standard ISO possono esistere metodi di codifica diversi. I codici si differenziano per il numero di byte per ogni
28 - Tecno1 rel. 17.03.17
carattere e codici che invece possono usare un numero diverso di byte per rappresentare caratteri diversi.
Per definire un set di caratteri occorre specificare:
1. l’insieme dei codici utilizzato
2. l’insieme dei caratteri da rappresentare
3. la corrispondenza tra essi
Lo standard ASCII
Il set di caratteri ISO 646 usa la codifica ASCII (American Standard Code for Information Interchange) a 7 bit (detto anche ASCII di base o ristretto).
Questa codifica usa 8 bit per carattere, ma lascia inutilizzato il bit più significativo (sempre 0).
Ad ogni carattere viene associato in modo convenzionale un numero nell’intervallo 0 – 127; tale numero, o meglio, la sua rappresentazione binaria, costituisce la
rappresentazione del carattere (si può avere una rappresentazione esadecimale per avere una codifica più compatta)
Il codice di ciascun carattere può essere individuato in una tabella che elenca i caratteri e il codice corrispondente comprende 128 caratteri di base:





lettere maiuscole
lettere minuscole
cifre
simboli speciali, ad esempio + - ; : , ……)
caratteri di controllo: questi codici non producono un carattere visibile, ma indicano una funzione da eseguire. Ad esempio “ a capo, “tab”, “salto
pagina”,…).
In particolare:

I primi 32 caratteri sono caratteri di controllo

Le cifre da 0 a 9 hanno tutte lo stesso valore (0011) nel semibyte più significativo, mentre il secondo contiene la rappresentazione della cifra in binario.
Per passare dalla rappresentazione della cifra come carattere al suo valore numerico da usare nei calcoli, basta sottrarre 30h (00110000) e viceversa.

Le lettere sono suddivise in maiuscole e minuscole, mantenendo l’ordine alfabetico, quindi si possono eseguire operazioni di confronto e ordinamento
di caratteri, basandosi sul loro codice ASCII (attenzione: poiché le lettere maiuscole precedono le minuscole)
E’ evidente che per la maggior parte delle lingue 128 caratteri sono insufficienti (in italiano per esempio, ci sono le lettere accentate)
Il bit più significativo dell’ASCII base può essere utilizzato per estendere il codice e aggiungere altri 128 caratteri (con 8 bit ho 256 combinazioni)
In ASCII a 8 bit (ASCII esteso, a 8 bit -ISO 8859), tutti i codici sono compatibili con l’ ASCII A 7 bit (i primi 128 caratteri sono uguali).
29 - Tecno1 rel. 17.03.17
un esempio di ASCII Art -
Unicode
Il codice ASCII a 8 bit non è adatto per le lingue orientali che usano migliaia di ideogrammi, ciascuno dei quali corrisponde non a un suono (come una lettere) ma
ad un intero concetto o parola. E’ necessaria allora una codifica che usi almeno 16 bit (65536 caratteri).
Nel 1991 è stato istituito il consorzio Unicode per definire uno standard a 16 bit internazionale
noto come codice Unicode. Il set di caratteri Unicode comprende le lettere di tutti gli alfabeti,
molti simboli speciali e ideogrammi; se un elemento appartiene a più lingue compare una volta
sola; questo vale anche per l’insieme degli ideogrammi, indicato con la sigla CJK (cinese,
giapponese,coreano) ricavato dai nomi delle tre lingue principali; in questo modo si riduce il
numero degli elementi da codificare.
I primi 128 caratteri sono identici a quelli dell’ISO 646 e i primi 256 all’ISO 8859-1. (standard ISO
Latin-1). Tuttavia, poiché ogni carattere Unicode è codificato con 16 bit, lo standard Unicode non
è strettamente compatibile con le codifiche a 8 bit; per esempio il codice Unicode della lettere A
è 0041h mentre l’ASCII è 41h.
La codifica dei caratteri Unicode è nota come UCS-2 (Universal Character Set a 2 byte). Il codice
Unicode è usato dai sistemi operativi Windows per la memorizzazione dei nomi dei file e per
l’inserimento di simboli nei documenti, e da Java per la codifica di tutti i caratteri.
Nel 1991 è stato istituito il consorzio Unicode per definire uno standard a 16 bit internazionale noto come codice Unicode. Il set di caratteri Unicode comprende
le lettere di tutti gli alfabeti, molti simboli speciali e ideogrammi; se un elemento appartiene a più lingue compare una volta sola; questo vale anche per
l’insieme degli ideogrammi, indicato con la sigla CJK (cinese, giapponese,coreano) ricavato dai nomi delle tre lingue principali; in questo modo si riduce il numero
degli elementi da codificare.
I primi 128 caratteri sono identici a quelli dell’ISO 646 e i primi 256 all’ISO 8859-1. (standard ISO Latin-1).
Tuttavia, poiché ogni carattere Unicode è codificato con 16 bit, lo standard Unicode non è strettamente compatibile con le codifiche a 8 bit; per esempio il codice
Unicode della lettere A è 0041h mentre l’ASCII è 41h.
La codifica dei caratteri Unicode è nota come UCS-2 (Universal Character Set a 2 byte). Il codice Unicode è usato dai sistemi operativi Windows per la
memorizzazione dei nomi dei file e per l’inserimento di simboli nei documenti, e da Java per la codifica di tutti i caratteri.
Nel 1993 l’ISO ha definito un nuovo standard ISO 10646 e la relativa codifica UCS-4. Vengono usati 4 byte, con il primo bit a 0, cioè 31 bit effettivi. Il 10646 è il
set di caratteri indicato nella specifica del linguaggio HTML 4.0.
Esempio di Unicode per caratteri cuneiformi
Esercizio 1
Si desidera salvare su file in formato ASCII (ISO-8859-1) un testo di 100 pagine, ognuna composta
da 50 righe di 69 caratteri. Ogni riga e terminata dal carattere LF ed ogni pagina è terminata dal carattere FF. Calcolare la dimensione del file espressa in kB.
[ 341.9 kB ]
Un carattere ASCII è codificato su 8 bit, ovvero un byte, sia esso un carattere di testo o uno di controllo (es. i caratteri LF e FF citati nel problema). Una pagina
occupa quindi: [50 ·(69+1)] +1 = 3501 Byte.
Moltiplicando per il numero di pagine ed applicando il fattore di scala per i KByte, si ottiene la dimensione del file:
Dimensione file = 3501 · 100= 341.9 kB
Esercizio 2
Su una cartella da 1.44 MB si devono scrivere i dati relativi agli studenti di una scuola. Ad ogni studente corrisponde un file che contiene i seguenti dati:
• cognome (32 caratteri ASCII)
• nome (32 caratteri ASCII)
• data di nascita (GGMMAAAA codificata in BCD)
• matricola (numero intero di 6 cifre codificato in ASCII)
30 - Tecno1 rel. 17.03.17
Calcolare il numero massimo di studenti i cui dati possono essere scritti sulla cartella. [ 20404 studenti ]
Un carattere ASCII e codificato su 8 bit, ovvero un byte. Una cifra decimale in codifica BCD occupa 4 bit. Una cifra decimale rappresentata in ASCII necessita di un
carattere. Ne consegue: 32 · 1 B +32 · 1 B+8 · 0.5 B+6 · 1 B = 74 Byte/studente
1.44 · MB / 74 =20,404.7 studenti = 20,404 studenti
Esercizio 3
Si desidera salvare su file in formato Unicode con codifica UTF-8 un testo in lingua Italiana composto da 20000 caratteri. Sapendo che in Italiano la frequenza
media delle lettere accentate e il 5%, stimare la dimensione del file espressa in kB. [ 20.5 KB ]
La codifica UTF-8 richiede da 1 a 4 byte per carattere, a seconda del tipo. I caratteri presenti nell’alfabeto ASCII a 7 bit (tra cui ricadono i normali caratteri Italiani)
richiedono un byte, mentre i caratteri con simboli diacritici (tra cui ricadono i caratteri accentati Italiani) richiedono due byte.
(5% => 1000 * 2= 2000 byte accentati)
19000 + 2000 = 21000 21000/1024=20.5Kbyte
Codice QR
testo “Tecno 1”:
“Un Codice QR è un bidimensionale a , composto da moduli neri
disposti all'interno di uno schema di forma quadrata. Viene
impiegato per memorizzare informazioni generalmente destinate
ad essere lette tramite un o uno . In un solo crittogramma sono
contenuti 7.089 caratteri numerici e 4.296 alfanumerici. Il nome
QR è l'abbreviazione dell' quick response (risposta rapida), in virtù
del fatto che il codice fu sviluppato per permettere una rapida
decodifica del suo contenuto” (Wikipedia). Per approfondimenti si
veda:
31 - Tecno1 rel. 17.03.17
codifica di immagini e suoni
Immagini
Lettere e numeri non costituiscono le uniche informazioni utilizzate dagli elaboratori, ma molte applicazioni utilizzano ed elaborano anche altri tipi di
informazione: diagrammi, immagini, suoni.
Spesso in questi casi si parla di applicazioni di tipo multimediale.
(Per un approfondimento si veda: )
_
Non sempre il contorno della figura coincide con le linee della griglia. Quella che si ottiene nella codifica è un'approssimazione della figura originaria
_
La rappresentazione sarà più fedele all'aumentare del numero di pixel, ossia al diminuire delle dimensioni dei quadratini della griglia in cui è suddivisa l'immagine
risoluzione dell’immagine.
Assegnando un bit ad ogni pixel è possibile codificare solo immagini senza livelli di chiaroscuro. Le immagini in bianco e nero hanno delle sfumature (diversi livelli
di intensità di grigio).
Per codificare le immagini con diversi livelli di grigio si stabilisce per ogni pixel il livello medio di grigio, cui viene assegnata convenzionalmente una
rappresentazione binaria. Per memorizzare un pixel non è più sufficiente un solo bit. Ad esempio, se utilizziamo quattro bit possiamo rappresentare 24 = 16 livelli
di grigio, mentre con otto bit ne possiamo distinguere 28 = 256, ecc.
Analogamente possiamo codificare le immagini a colori. In questo caso si tratta di individuare un certo numero di sfumature di colore differenti e di codificare
ogni sfumatura mediante un'opportuna sequenza di bit.
La rappresentazione di un'immagine mediante la codifica dei pixel, viene chiamata codifica bitmap e l’immagine viene detta discretizzata.
Il numero di byte richiesti dipende dalla risoluzione e dal numero di colori che ogni pixel può assumere.
I monitor utilizzano, ad esempio, risoluzioni di 640X480, 1024X768, oppure 1280X1024 ed un numero di colori per pixel che va da 256 fino a sedici milioni di
colori. Per distinguere 256 colori sono necessari otto bit per la codifica di ciascun pixel: la codifica di un'immagine formata da 640X480 pixel richiederà 2.457.600
bit (307.200 byte). Esistono delle tecniche di compressione delle informazione che consentono di ridurre drasticamente lo spazio occupato dalle immagini.
Le immagini in movimento vengono memorizzazione mediante sequenze di fotogrammi (sono necessarie delle tecniche per ottimizzare tale memorizzazione).
32 - Tecno1 rel. 17.03.17
Grafica Digitale
Digital graphic images can be divided into one of two fundamental types:
Vector Graphics and Raster Graphics (bitmap, pixel).
Raster Graphics (commonly called bitmap images) are made of pixels. Photographs are an example of a bitmap image. They have a fixed resolution
and cannot be resized larger without losing quality.
Common bitmap file formats end in: .gif .jpg .png .tiff & .bmp
Bitmap images typically have much larger file sizes than the same image as a vector graphic so they are often compressed to reduce their size. Bitmap images
can be converted from one format to another with programs such as Photoshop.
Vector Graphics are images that have been created in a drawing program such as Adobe Illustrator. They use paths to create lines and curves at connecting points called "nodes" to store the graphic's information mathematically. Vector art is resolution independent; whether you enlarge or shrink the image,
the output quality is never compromised. This is why logos should always be created in vector art format. Common file formats for vector art used in the commercial printing industry include: .ai .esp & .pdf
A common public misconception is that using “ > SAVE AS” and saving to another file format will somehow fix the problem. Pixel-based raster art will always be
made out of pixels regardless of what file format one save the image as. It is possible to convert raster art into vector with methods such as “LIVE TRACE” in
Adobe Illustrator, but the results are usually less than satisfcactory when used on a corporate logo.
Grafica Raster (bitmap)
http://it.wikipedia.org/wiki/Grafica_bitmap
La grafica bitmap, o grafica raster (in inglese bitmap graphics, raster graphics), è una tecnica utilizzata in computer grafica per descrivere un'immagine.
Nella grafica raster l'immagine viene vista come una scacchiera e ad ogni elemento della scacchiera, chiamato pixel, viene associato uno specifico colore.
Il colore può essere definito con due tecniche: se l'immagine contiene pochi colori (massimo 256) si crea un elenco dei colori da utilizzare e nella scacchiera
viene inserito l'indice che punta allo specifico colore del pixel;nel caso si vogliano utilizzare molti più colori il singolo pixel non definisce più l'indice a una
tavolozza di colori ma definisce il colore direttamente.
Il colore viene definito come un'unione delle componenti blu, rossa e verde.
Rappresentazione dei colori
Base fisiologica: un colore visibile all'occhio umano può essere descritto da una composizione di luce
rossa, verde, blu (colori primari)
Modello additivo di colore RGB (Red Green Blue):
– un dato colore è descritto dalla combinazione delle intensità dei tre colori primari
– associando un numero a ciascun livello di intensità, è possibile definire una rappresentazione digitale di un colore
33 - Tecno1 rel. 17.03.17
aumentando il numero di pixel , l’immagine migliora
La bitmap è caratterizzata da due proprietà:
risoluzione; numero di pixel per pollice (equivalente a 2,54 cm); si misura in PPI (Pixel Per Inch) oppure in DPI (Dot Per Inch, Punti per pollice).
profondità di colore. numero di bit , associati a ogni pixel, usati per descrivere il colore. Si misura in BPP (Bit Per Pixel); maggiore è il numero di bit, maggiore è il
numero di colori che è possibile descrivere.
(http://www2.ing.unipi.it/~a009395/corsi/ig/pdf/Rappresentazione%20delle%20immagini.pdf )
NOTA
Risoluzione di un dispositivo di uscita (p.e. monitor, stampante):
– numero di pixel per unità di misura lineare (p.e. pollice), ppi (pixel per inch), dpi (dots per inch)
Risoluzioni tipiche
Monitor: 72-100 dpi
Stampante: 2400-4800 dpi Scanner: 2400 dpi
Dimensioni fisiche assolute di un’immagine raster (in pollici) = Dimensione lineare in punti/risoluzione in punti per pollice
Es: immagine 1024x768 punti, risoluzione 300 dpi
– Larghezza= 1024/300 = 3.41 inch
– Altezza= 768/300 = 2.56 inch
I dati raster possono essere memorizzati attraverso tipologie di file che sfruttano algoritmi di compressione diversi, gravando in modo differente sul supporto di
memorizzazione. I formati raster più comuni sono i seguenti:
Formati di immagini raster
Questi formati di file hanno richieste di elaborazione minima, non essendo necessari algoritmi di compressione (in fase di scrittura) e decompressione (in fase di
lettura), tuttavia, mancando di compressione, risultano particolarmente voluminosi, in termini di spazio occupato su disco (o altro dispositivo di
memorizzazione), rispetto agli altri formati:
(in alcuni casi i file bmp sono compressi con un algoritmo )
compressione lossless (senza perdita di informazione)
Le immagini salvate con un di occupano meno spazio nei dispositivi di memorizzazione, mantenendo inalterata tutta l'informazione originale:
(certe applicazioni permettono anche la scrittura di file png non compressi)
(sebbene questo sia l'uso più comune, questo formato permette diversi tipi di compressione)
(per immagini fino a 256 colori)
compressione lossy (con perdita di in formazione)
Le immagini memorizzate con un algoritmo di compressione subiscono una perdita di informazione; pertanto questa tecnica non è adatta per salvare le
immagini che vengono rielaborate coi programmi di fotoritocco (le continue modifiche comporterebbero un progressivo degrado dell'immagine ad ogni
salvataggio e riapertura); invece, in virtù delle ridotte dimensioni del file, sono particolarmente indicate per la trasmissione di immagini o per ridurre le
dimensioni di un'applicazione o di un prodotto da distribuire.
(per immagini con più di 256 colori si ottiene una compressione lossy poiché vengono eliminate la maggior parte delle sfumature di colore)
Grafica vettoriale
Un'immagine descritta con la grafica vettoriale è chiamata immagine vettoriale.
Nella grafica vettoriale un'immagine è descritta mediante un insieme di che descrivono punti, , e ai quali possono essere attribuiti colori e anche sfumature. È
radicalmente diversa dalla in quanto nella grafica raster le immagini vengono descritte come una griglia di opportunamente colorati.
L'elemento base della grafica vettoriale sono gli elementi geometrici:

linee
34 - Tecno1 rel. 17.03.17

curve

aree
Quali elementi siano disponibili per il disegno, e quali siano le loro proprietà specifiche, è definito da un linguaggio – ne esistono molti.
Un disegno in grafica vettoriale può essere visto come un insieme di istruzioni (immagine) rivolte a un disegnatore (motore di rendering) ed espresse in un dato
linguaggio (formato).
Di ciascun elemento è data una rappresentazione matematica astratta (equazioni). Le varie parti che compongono l'immagine sono separabili .
Esempio:

varie curve chiuse

aree interne colorate

linee di confine (bordi) visibili o meno
Il caso più semplice è quello in cui la “curva” è in realtà formata da una sequenza di segmenti di retta. Tuttavia, questa approssimazione è troppo grossolana se la
curva viene ingrandita o manipolata. Analogamente avviene per l'approssimazione di un cerchio con un poligono con un numero elevato di lati:
Si usano quindi delle reali curve (in senso matematico): funzioni parametriche di tipo analitico; le funzioni parametriche hanno un valore che varia al variare di un
parametro t ; al momento del disegno, il motore di rendering calcola le equazioni e disegna la curva corrispondente.
Il caso più semplice è quello della retta. Il segmento di retta fra due punti P0 e P1 è definito dall'equazione nella figura sotto. Va notato che P0 e P1 sono due
vettori, ovvero coppie [x y] – t è invece un numero reale; la moltiplicazione si effettua con entrambe le componenti
equazione di una retta
La grafica vettoriale, essendo definita attraverso equazioni matematiche, è indipendente dalla risoluzione, mentre la grafica raster, se viene ingrandita o
visualizzata su un dispositivo dotato di una risoluzione maggiore di quella del monitor, perde di definizione.
Una linea che percorre lo schermo trasversalmente se viene rappresentata utilizzando la grafica raster viene memorizzata come una sequenza di pixel colorati
disposti a formare la linea. Se si provasse ad ingrandire una sezione della linea si vedrebbero i singoli pixel che compongono la linea. Se la medesima linea fosse
memorizzata in modo vettoriale la linea sarebbe memorizzata come un'equazione che parte da un punto identificato con delle coordinate iniziali e termina in un
altro punto definito con delle coordinate finali. Ingrandire una sezione della linea non produrrebbe artefatti visivi o la visualizzazione dei singoli pixel componenti
l'immagine, dato che la linea sarebbe visualizzata sempre con la massima risoluzione consentita dal monitor.
Ad esempio, prendendo un'immagine vettoriale grande 2x24 pixel e aumentando la risoluzione fino a 1024x768, si otterrà una immagine che ha la stessa
definizione di quando era 2x24. Se noi procediamo con lo zoom su di un file di tipo bitmap adattato a 800x600 px e lo ingrandiamo a 1024x768 px la definizione
risulta inferiore, questo perché il processore non ricalcola la definizione dell'immagine come succede nelle immagini vettoriali ma utilizza le stesse informazioni
(pixel) dell'immagine su una superficie maggiore. (https://it.wikipedia.org/wiki/Grafica_vettoriale)
Semplificando, possiamo dire che una linea retta nera in formato vettoriale verrà descritta da una formula che, volgarizzando, suonerà più o meno così:
“dal punto (x,y) parte una linea di colore nero che termina al punto (x,z)”.
La stessa linea retta in formato bitmap avrà una descrizione che suonerà invece così:
“il punto (x,y) è nero, il punto (x,a) è nero, il punto (x,b) è nero...” e così via, fino al raggiungimento del termine della linea: viene cioè descritta la dislocazione di
tutti i singoli punti che costituiscono l'immagine, con il loro relativo valore di colore.
La grafica vettoriale ha un notevole utilizzo nell'editoria, nell'architettura, nell'ingegneria e nella grafica realizzata al computer. Tutti i programmi di grafica
tridimensionale salvano i lavori definendo gli oggetti come aggregati di primitive matematiche. Nei personal computer l'uso più evidente è la definizione dei font.
Quasi tutti i font utilizzati dai personal computer vengono realizzati in modo vettoriale, per consentire all'utente di variare la dimensione dei caratteri senza
perdita di definizione.
35 - Tecno1 rel. 17.03.17
Suoni
Anche i suoni possono essere rappresentati informa digitale
Dal punto di vista fisico un suono è un'alterazione della pressione dell'aria che, quando rilevata dall'orecchio umano, viene trasformata in un particolare stimolo
al cervello
La durata, l'intensità e la variazione nel tempo della pressione dell'aria sono le quantità fisiche che rendono un suono diverso da ogni altro
Un suono può essere descritto mediante l’onda di pressione che rappresenta la variazione della pressione dell’aria nel tempo.
Sull’asse delle ascisse viene rappresentato il tempo e sull’asse delle ordinate viene rappresentata la pressione corrispondente al suono stesso.
La conversione di un segnale continuo in una successione di numeri viene eseguita con due successive operazioni elementari
_
1. Campionamento del segnale (cioè si preleva una successione di campioni a intervalli costanti di tempo)
2. Ogni campione viene quantizzato, ossia convertito in un numero (si codificano in forma digitale le informazioni estratte dal campionamento)
•
1.
Esercizi riepilogativi
Hai ricevuto un messaggio di posta elettronica da un amico. Il messaggio contiene:
1.
un testo di 300 caratteri scritto in ASCII,
2.
un'immagine di 120x150 pixel con 1024 colori.
Quanti byte occupa il messaggio?
Testo: 300 byte. Immagine: ogni pixel richiede 10 bit (perché 210=1024); l'immagine ha 120 x 150 = 18000 pixel; l'immagine occupa 10 x 18000 =
180000 bit = 22500 byte. Testo + immagine: 300 + 22500 = 22800 byte
2.
Un'immagine di 300x400 pixel occupa 15000 byte. L'immagine è a colori oppure in bianco e nero?
L'immagine ha 300 x 400 = 120000 pixel, ed occupa 15000 x 8 = 120000 bit. Cioè ad ogni pixel corresponde a un bit, e l'immagine è in bianco e nero
3.
Quanto spazio occupa un'immagine animata di 100x100 pixel a 128 colori, formata da 6 frame?
Ogni frame ha 100 x 100 = 10000 pixel; ogni pixel richiede 7 bit (perché 27=128); ogni frame occupa 10000 x 7 = 70000 bit; l'immagine animata occupa
70000 x 6 = 420000 bit (= 52500 byte)
Codifica dei caratteri

Quanti byte occupa i testi seguenti scritti in Extended ASCII?
o
cervello
8
o
dipartimento di psicologia
26
o
[email protected]
20
Codifica delle immagini
1.
Un'immagine in bianco e nero è formata da 400x400 pixel. Quanti bit occupa l'immagine? Quanti byte occupa l'immagine?
Ogni pixel richiede un bit (perché l'immagine è in bianco e nero); l'immagine ha 400 x 400 = 160000 pixel; l'immagine occupa 160000 bit; 160000 bit =
20000 byte
2.
Un'immagine a 256 colori è formata da 400x400 pixel. Quanti byte occupa l'immagine?
Ogni pixel richiede un byte (=8 bit, perché 28=256, sufficiente per rappresentare 256 colori); l'immagine ha 400 x 400 = 160000 pixel; l'immagine occupa 160000 byte
36 - Tecno1 rel. 17.03.17
3.
Un'immagine a 16777216 colori è formata da 100x100 pixel. Quanti byte occupa l'immagine?
Ogni pixel richiede 3 byte (perché 224=16777216, sufficiente per rappresentare 16777216 colori); l'immagine ha 100 x 100 = 10000 pixel; l'immagine
occupa 30000 byte
4.
Hai ricevuto un messaggio di posta elettronica da un amico. Il messaggio contiene:
o
un testo di 300 caratteri scritto in Extended ASCII,
o
un'immagine di 120x150 pixel con 1024 colori.
Quanti
byte
occupa
il
messaggio?
Testo: 300 byte. Immagine: ogni pixel richiede 10 bit (perché 2 10=1024); l'immagine ha 120 x 150 = 18000 pixel; l'immagine occupa 10 x 18000 =
180000 bit = 22500 byte. Testo + immagine: 300 + 22500 = 22800 byte
5.
Un'immagine di 300x400 pixel occupa 15000 byte. L'immagine è a colori oppure in bianco e nero? Nel caso in cui l'immagine è a colori, quanti colori
ha l'immagine?
L'immagine ha 300 x 400 = 120000 pixel, ed occupa 15000 x 8 = 120000 bit. Cioè ad ogni pixel corresponde a un bit, e l'immagine è in bianco e nero
6.
Un'immagine di 500x500 pixel occupa 250000 byte. L'immagine è a colori oppure in bianco e nero? Nel caso in cui l'immagine è a colori, quanti colori
ha l'immagine?
L'immagine ha 500 x 500 = 250000 pixel, ed occupa 250000 x 8 = 2000000 bit. Cioè ad ogni pixel corresponde a 2000000/250000 = 8 bit, e l'immagine
ha 28=256 colori (la prima soluzione dato su questa pagina era erratta)
7.
Un'immagine di 100x200 pixel occupa 10000 byte. L'immagine è a colori oppure in bianco e nero? Nel caso in cui l'immagine è a colori, quanti colori
ha l'immagine?
L'immagine ha 100 x 200 = 20000 pixel, ed occupa 10000 x 8 = 80000 bit. Cioè ad ogni pixel corresponde a 80000/20000 = 4 bit, e l'immagine ha 2 4=16
colori
Codifica dei suoni
1.
Quanti byte occupa un suono della durata di 5 secondi campionato a 30 Hz (30 campioni per secondo), in cui ogni campione occupa 6 byte?
5 x 30 x 6 = 900 byte
2.
Un secondo di suono campionato a 512 Hz occupa 1 KB. Quanti valori distinti possono avere i campioni?
1 KB = 1024 byte; numero di campioni = 1 x 512 = 512; ogni campione contiene 1024/512 = 2 byte; 2 byte = 16 bit; 2 16 valori distinti
Compressione dati
Ottimizzazione dei messaggi
(tratto da Marcello Guidotti, 1999-2003)
Supponiamo di voler insegnare ad una scimmia il linguaggio gestuale in modo da farle scegliere di volta in volta il cibo che desidera mangiare: banane, budino,
arachidi, torta di lamponi. Un modo semplice è insegnare alla scimmia due segnali per comunicare i propri desideri: per esempio, alzare la mano sinistra oppure
la destra (codifica 1 di tab. I). Ognuno di questi due segnali fornisce l'informazione di 1 bit (il più piccolo segnale richiesto per comporre il messaggio).
cibo
banana
budino
torta
frequenza
9
6
2
codifica 1
D
S
DD
codifica 2
DD
DS
SS
codifica 3
D
SD
SSD
arachidi
1
DS
SD
SSS
tab. I
Ben presto, però, con questa codificazione si incontrerebbero le prime difficoltà di interpretazione. Supponiamo che la scimmia alzi tre volte la mano destra
(DDD). Che cosa significa? Vuole tre banane, oppure una banana e due fette di torta? Certo, si potrebbe ovviare aggiungendo un segnale di interruzione fra un
messaggio e l'altro: ad esempio toccarsi la fronte con la mano destra. Ma questo sarebbe un terzo segnale e noi vogliamo utilizzarne solo due (praticamente il
numero zero ed il numero 1).
Convenendo di indicare ogni cibo con due alzate di mano (codifica 2 di tab. I), la scelta diventa inequivocabile. La sequenza DDSDSSSS significa: una banana, una
busta di arachidi, due porzioni di torta. In base a questa convenzione, possiamo affermare che ogni singola richiesta della scimmia comporta due segnali ossia 2
37 - Tecno1 rel. 17.03.17
bit d'informazione, mentre per il menù completo (4 portate) occorrono 8 bit. Questa codificazione è efficiente (raggiunge il risultato) ma non è detto che sia
efficace (raggiunge il risultato nel miglior modo possibile).
Se osserviamo le richieste della scimmia nell'arco di una settimana, potremmo ad esempio constatare che le arachidi non sono il cibo preferito dalla scimmia,
mentre lo sono le banane. In altre parole, il segnale SD (arachidi) si presenta molto raramente, mentre il segnale DD (banane) è assai frequente. Di questo fatto
bisogna tener conto per una codificazione ottimale. Supponiamo di aver constatato che la scimmia mangi ogni giorno nove banane, sei porzioni di budino, due
fette di torta, una busta di arachidi.
Per rendere la codificazione ottimale, l'ordinazione delle banane deve essere individuata con un segnale quanto più possibile breve. Invece, il segnale per
l'ordinazione delle arachidi potrebbe essere più lungo. Nel corso di una giornata, la scimmia consuma 18 portate le quali, nella efficiente codificazione 2 di tab.I,
richiedono 36 segnali, ossia 36 bit.
Supponiamo di codificare le banane con l'alzata della mano destra: segnale D. Per evitare l'ambiguità nella scelta del prossimo cibo, il prossimo segnale deve
essere SD. Infatti, in una sequenza di segnali, la combinazione DD farebbe sorgere il dubbio che fossero desiderate due volte banane. Anche DS potrebbe in
qualche modo lasciare una certa ambiguità. Insomma, con un pò di tentativi (in pratica con la codifica Huffman), si può costruire la codificazione 3 di tab. 1.
L'ordinazione di 9 banane al giorno richiede ora soltanto 9 bit, contro i 18 bit della precedente codificazione. In più, sono da aggiungere quotidianamente 12 bit
per le 6 porzioni di budino, 6 bit per le 2 fette di torta, 3 bit per la busta di arachidi. In totale 30 bit in confronto ai 36 della codificazione: questa nuova
codificazione è senz'altro efficiente, ed è anche più efficace della codificazione 2. Al contrario, la codificazione 1, pur richiedendo solo 21 bit, si presta ad
equivoci, quindi non è efficiente e dunque è da scartare.
Quanto accennato è sufficiente per comprendere come sia possibile compattare i files di dati e programmi riducendone le dimensioni. Sono in commercio
programmi (uno dei più noti è WINZIP) che permettono facilmente di effettuare la compressione. Con lo stesso principio funzionano i programmi che permettono
di aumentare lo spazio su disco: i dati vengono compressi durante il loro salvataggio e quindi decompressi durante la lettura; è ovvio che il tempo di accesso ai
dati aumenta in conseguenza delle operazioni di codifica-decodifica, ma il continuo aumento della velocità di elaborazione dei processori, rende l'operazione
interessante.
A questo punto, ci si potrebbe chiedere la ragione per cui i messaggi non sono già codificati nel modo più efficace. La risposta è semplice: non tutti i segnali si
presentano con la stessa frequenza. In realtà, i programmi di compressione sono essenzialmente basati sullo schema visto sopra, relativo alla codifica Huffman, in
cui, prima che un programma sottoponga un file di dati (dati alfanumerici e/o immagini) a compressione, esegue un controllo statistico sulla frequenza degli
elementi componenti il messaggio. Per esempio, la stringa "aaaaaaaaaaaaaaaaaaaaa" sarà compressa con un fattore del 67% circa, ma la stringa
"abcdefghilmnopqrstuvz" non potà essere compressa!
Possiamo percio’ dire che la compressione dati è il processo che trasforma un certo insieme di dati in una rappresentazione piu' piccola, dalla quale, è possibile
(con la decompressione) risalire all'originale.
Le applicazioni piu' comuni riguardano non solo la memorizzazione dei file di dati ma anche la loro trasmissione: non solo testo (zip) e immagini (jpg, gif) ma
anche filmati (mpeg) e musica (mp3). Se un file viene ad ex. compresso con fattore 2 allora la velocità della linea apparirà duplicato! Non tutti le fonti di dati
possono essere compresse, come ad esempio i dati casuali (ad ex. un file .exe) o i dati già compressi in modo ottimale. Inoltre non si puo' affermare con certezza
che una stessa compressione raggiunga lo stesso risultato su diversi tipi di dati.
Esistono vari algoritmi di compressione dati. Essi possono essere distruttivi se perdono parte del contenuto informativo o non distruttivi se mantengono
inalterato il contenuto informativo. Essi si possono classificare in classi:
Tecniche non distruttive (senza perdita di informazione)
Algoritmi di compressione che operano con codici di lunghezza fissa.
Sono algoritmi basati su approcci di forza bruta (brute force) come ad ex. la NULL COMPRESSION (una delle prime tecniche usate) in cui l'idea è quella di scandire
i dati alla ricerca del carattere spazio (blank). Il primo carattere è un indicatore di compressione , il secondo rappresenta il numero di blank compressi. Ad ex.:
stringa originaria: CIAO
MAMMA
stringa compressa: CIAO^8MAMMA
dove ^ è il carattere di compressione e 8 il numero di blanks
Molte sono le varianti di questa compressione con miglioramenti aggiustamenti

Bit Mapping in cui viene aggiunta una mappa di bit all' inizio della stringa che sta a indicare la presenza di blank : 1 bit => 1 blank

Run Lenght Encoding in cui una serie di generici simboli sono rimpiazzati dal simbolo stesso preceduto dal numero di repliche . Ad ex. AAABBCCC:
3A2B3C etc)

Modulazione a impulsi differenziali (DPCM) L' idea consiste nel produrre un simbolo di riferimento seguito dalla distanza del simbolo da quello di
riferimento.. Ad ex AAABBCCCDD: A001122233. In questo caso la distanza puo' essere codificata con soli 2 bit (0,1,2,3) al posto di 8 bit per carattere.
Cio' è utile ad ex. per immagini dove le "distanze" tra pixel adiacenti sono piccole perchè i pixel spesso sono simili.
Algoritmi di compressione statici
che, basandosi sulla frequenza di occorrenza di ogni carattere o gruppo di caratteri che compaiono nel
testo, assegnano codici lunghi ai caratteri che vengono usati raramente e codici brevi ai caratteri maggiormente frequenti. In questo modo, mediamente, i
messaggi ottenuti saranno codificati in modo piu' corto.
Ad ex. lo stesso codice Morse assegna alle lettere E e T , che sono molto comuni nella lingua inglese, i codici . e linea rispettivamente, mentre i famosi ... --- ...
corrispondono a SOS , lettre molto meno frequenti.
Il metodo, di tipo statico, piu' popolare e noto è la Codifica di Huffman il cui vantaggio principale è quello di ridurre la lunghezza media del codice utilizzando un
38 - Tecno1 rel. 17.03.17
prefisso scelto in modo tale che non possa mai essere lo stesso per sequenze piu' lunghe.
Quest'algoritmo non distruttivo fu inventato nel 1952 dal matematico D.A. Huffman ed è un metodo di compressione particolarmente ingegnoso.
David A. Huffman ( – ).
Durante la sua vita, Huffman ha dato contributi significativi allo studio delle macchine a stati finiti, dei circuiti di
commutazione, nelle procedure di sintesi e nella progettazione dei segnali. Tuttavia, David Huffman è più noto per la
leggendaria , un algoritmo di compressione per la codifica lossless (senza perdita di dati) di lunghezza variabile. È il
risultato di una tesi scritta quando era dottorando presso il nel 1953. (wikipedia)
Funziona in questo modo:

Analizza il numero di ricorrenze di ciascun elemento costitutivo del file da comprimere: i singoli caratteri in un file di testo, i pixel in un file
grafico.

Accomuna i due elementi meno frequenti trovati nel file in una categoria-somma che li rappresenta entrambi. Così ad esempio se A ricorre 8
volte e B 7 volte, viene creata la categoria-somma AB, dotata di 15 ricorrenze. Intanto i componenti A e B ricevono ciascuno un differente
marcatore che li identifica come elementi entrati in un'associazione.

L'algoritmo identifica i due successivi elementi meno frequenti nel file e li riunisce in una nuova categoria-somma, usando lo stesso procedi mento descritto al punto 2. Il gruppo AB può a sua volta entrare in nuove associazioni e costituire, ad esempio, la categoria CAB. Quando ciò
accade, la A e la B ricevono un nuovo identificatore di associazione che finisce con l'allungare il codice che identificherà univocamente ciascu na delle due lettere nel file compresso che verrà generato.

Si crea per passaggi successivi un albero costituito da una serie di ramificazioni binarie, all'interno del quale appaiono con maggiore frequen za e in combinazioni successive gli elementi più rari all'interno del file, mentre appaiono più raramente gli elementi più frequenti. In base al
meccanismo descritto, ciò fa sì che gli elementi rari all'interno del file non compresso siano associati ad un codice identificativo lungo, che si
accresce di un elemento ad ogni nuova associazione. Gli elementi invece che si ripetono più spesso nel file originale sono anche i meno pre senti nell'albero delle associazioni, sicché il loro codice identificativo sarà il più breve possibile.

Viene generato il file compresso, sostituendo a ciascun elemento del file originale il relativo codice prodotto al termine della catena di asso ciazioni basata sulla frequenza di quell'elemento nel documento di partenza.
Il guadagno di spazio al termine della compressione è dovuto al fatto che gli elementi che si ripetono frequentemente sono identificati da un codice breve, che
occupa meno spazio di quanto ne occuperebbe la loro codifica normale.
Consideriamo ad esempio il caso mostrato in figura di 4 simboli K1,K2,K3 e K4 che vengono sistemati in base alla loro frequenza di occorrenza in una struttura ad
albero in cui i simboli piu' frequenti sono in alto. I due simboli a minor frequenza (K3 e K4) vengono uniti in un nodo con frequenza 0.25.Tale nodo viene poi
unito al simbolo meno frequente tra i rimasti (K2) generando un nuovo nodo a frequenza 0.4375, che viene poi unito a K1 generando un nodo con frequenza 1.
Assegnando 0 e 1 ad ogni segmento dell'albero a partire da destra (radice) si ottiene il codice di Huffman per ogni carattere.
La caratteristica del codice è quella di poter essere decodificata immediatamente.
Messaggio
Codificato
0
10
0
111
10
110 10
0
Messaggio
decodificato
K1
K2
K1
K4
K2
K3
K1
K2
Consideriamo un altro esempio: la frase: TRENTATRE TRENTINI ANDARONO A TRENTO
1) OCCORRENZE
2) ASSOCIAZIONI
E=4
E=4
A=4
A=4
N=6
O=3
A=4
N=6
D=1
AE = 8
N=6
R=5
AE = 8
R_ = 9
E=4
AET = 15
N=6
T=7
AET = 15
N=6
I=2
AET = 15
R=5
_=4
R_ = 9
N=6
DI = 3
R_ = 9
DIO = 3
O=3
DIO = 3
R=5
DIO = 3
T=7
DIO = 3
T=7
DION = 12
R=5
DIONR_ = 21
T=7
39 - Tecno1 rel. 17.03.17
_=4
T=7
_=4
_=4
Questo codice è molto semplice e lineare ma si complica moltissimo se i simboli sono molti. Inoltre codifiche come questa si basano sulla conoscenza a priori dei
dati da comprimere e della loro frequenza relativa.
- Compressione Adattativa (basata sul dizionario). A differenza delle tecniche precedenti, che si basavano sulla conoscenza a priori dei dati, in questi algoritmi, il
dato che deve essere compresso viene analizzato man mano che sui presenta e vengono apportate le opportune modifiche alla tabella dinamica di compressione
In altre parole vengono create delle tabelle con contatori interni, relativi ai caratteri incontrati, che vengono continuamente aggiornati in funzione delle
occorrenze, variando di conseguenza i codici di compressione, in modo efficiente e indipendente da una analisi a priori del file da comprimere.
Tra le varie tecniche di compressione di questo genere il BTLZ (basato sugli studi di Lampel e Ziv 1976/78) è un algoritmo di compressione adattativo ottenuto
sostituendo stringhe di caratteri con codici di lunghezza fissa. Esso è divenuto popolare attraverso implementazioni e variazioni diverse per l'uso nella
compressione dati usata nei modem (cfr. V42bis). I processi di codifica e decodifica usano un dizionario nei quali sono memorizzate le stringhe aggiornate
dinamicamente. Il dizionario è costituito, nella sua essenza, da una serie di alberi ciascuno dei quali ha per radice uno specifico carattere dell'alfabeto usato: se
ad ex. i simboli base sono 256, tali saranno gli alberi. Un nodo senza figli rappresenta l'ultimo carattere della stringa. Ad ex, consideriamo l'albero in struttura e
confrontiamo la stringa "dei cani". Analizzando in successione si trovano già nell'albero i caratteri d,e,i ma non ' ' . In questo caso viene spedito il codice 202 e
viene aggiunto all'albero, dopo la i, il carattere ' ' e viene assegnato ad esso un nuovo codice( ad ex, 206).: la prossima volta che sarà incontrata la stringa "dei "
verrà inviato il codice 206. ù
Cioè, se viene trovata la stringa S ma non il carattere c , esso viene aggiunto nel dizionario a formare la nuova stringa S=S+c.
La lunghezza delle stringhe usate di frequente crescerà molto velocemente. Il decodificatore presenta una struttura analoga al codificatore e, ricevuto il codice,
procede nella lettura al contrario dei caratteri che poi vengono riordinati. Naturalmente ogni cambiamento nel dizionario dell'encoder procede di pari passo con
il decoder.
Tecniche distruttive (con perdita di informazione)
Descriviamo qui la tecnica JPEG (Joint Photographic Expert Group) codificata dall' ISO 10918, usata soprattutto nel mondo di Internet, per le immagini, Da essa
discendono le tecniche di MPEG (Moving Picture Expert Group) per i filmati e MP3 (MPEG Audio Layer 3) per i file musicali. JPEG è una tecnica basata su tre
macro-fasi successive:
Nella fase DCT (Discrete cosine transform) viene attuata una trasformazione simile alla FFT (Fast Fourier Transform) , in cui dallo spazio dei pixel si passa nello
spazio delle frequenze. L’idea di base della DCT consiste nel separare le caratteristiche principali, che sono essenziali per la visione dell’immagine, dai dettagli che
sono meno importanti e che in alcuni casi potrebbero non venire percepiti neppure dall’occhio.
In particolare, dopo la preparazione dell'immagine in cui ogni matrice di pixel è divisa in blocchi da 8x8, si applica la DCT a ognuno dei blocchi separatamente.
L'output è una matrice 8x8 di elementi in cui i coefficienti rappresentano la quantità di potenza spettrale per ogni frequenza e (0,0) il valor medio. Nella fase di
quantizzazione, tramite una tabella a pesi differenziati, vengono eliminati i coefficienti DCT con frequenze alte, cioè i meno importanti, quelli che cambiano
molto rapidamente e quindi immaginabili come valori non facenti parte del blocco dell'immagine in cui i valori cambiano lentamente. Viene quindi applicata una
codifica runlenght e poi Huffman, assegnando ai numeri piu' probabili, codici piu' brevi. In realtà jpeg è complesso ma realizza compressioni di 20:1 e piu', con
perdita di informazione che pero' è poco percepita dall'occhio.
40 - Tecno1 rel. 17.03.17
MP3
(MPEG layer 3) si basa sulla codifica percettiva, per cui alcuni suoni mascherano altri suoni e non sono percepiti dall'orecchio umano. I suoni vengono campionati
con un certo bit rate (96Kbps), filtrati e codificati con un numero maggiore di bit per le bande con maggior potenza spettrale non mascherata e applicata la
codifica di Huffman.
Un programma di compressione per il suono quindi si comporta come una sorta di orecchio informatico che trasforma prima il suono nel suo spettro e
successivamente toglie dallo spettro tutte le armoniche che non vengono percepite. Se consideriamo che si può eliminare oltre il novanta per cento delle
frequenze presenti in un suono ci rendiamo conto della potenza di questo metodo: un suono che in origine occupava undici megabyte, dopo la compressione di
tipo percettivo ne occupa solo uno e la perdita di qualità tra queste due rappresentazioni del suono è quasi indistinguibile.
( http://www.mediamente.rai.it/mediamentetv/learning/corsi/0001c3_2.asp#8)
A
B
(a) Lo spettro sonoro (realizzato con Audacity, http://www.audacityteam.org/ ) mostra i livelli sonori in funzione della frequenza. Mentre una singola frequenza è
mostrata nel grafico con una singola riga, per un suono, da una serie di righe in corrispondenza alle frequenze fondamentali e alle loro armoniche, per una musica
lo spettro è rappresentato da una banda (insieme) di frequenze. In questo esempio il massimo delle frequenza è intorno ai 12000Hz. Ricordiamo che l'insieme
delle frequenze udibili dall'orecchio umano si estende da circa 20Hz a 20KHz ma la zona in cui l’orecchio è più sensibile è tra i 2KHz e 5KHz.
(b) Draw-Disegna : con zoom vicino al livello massimo , consente di regolare il volume dei singoli campioni audio Permette di appianare il contorno dei campioni ,
in modo che un campione sia regolato opportunamente rispetto ai campioni vicini .
-
41 - Tecno1 rel. 17.03.17
Introduzione ai Sistemi Operativi
Cos’è un Sistema Operativo
L'accesso diretto all'hardware può essere anche molto complesso. Il Sistema Operativo è un programma che agisce da intermediario tra un utente di un
computer e l’hardware nascondendone la complessità e fornendo una macchina “gradevole” per l’utente.
Sistemi Operativi e Distribuiti- Bellettini – Maggiorini
Il Sistema Operativo perseguie i seguenti scopi:

Gestire le applicazioni (Eseguire programmi utente)
o
Il sistema operativo carica i programmi, le applicazioni, in RAM assicurandosi che le risorse siano sufficienti alla sua esecuzione.
Le API (Application Programming Interface) sono un insieme di linee guida utilizzate dagli sviluppatori per garantire che le applicazioni che
stanno sviluppando siano compatibili con il sistema operativo.

Gestire file e cartelle
o
Il sistema operativo crea una struttura di file sulla memoria di massa per memorizzare i dati. Un file è un insieme di dati correlati a cui è
dato un nome univoco e che viene trattato come singola componente.

Controllare e ottimizzare l’accesso alle risorse hardware.
o
Per fare questo il sistema operativo installa un driver per ogni componente hardware. Il driver è un software scritto dal produttore
dell'hardware e fornito insieme al componente hardware che viene istallato con la periferica per comunicare con essa. Il sistema operativo
configura il dispositivo e aggiorna, in Windows, il registro che contiene informazioni sull’ hardware, il software, gli utenti le impostazioni di
rete e i file

Fornire una interfaccia utente . Ci sono due tipi di interfacce utente:
o
Interfaccia a Linea di Comando (CLI, Command Line Interface) in cui l'utente digita i comandi
o
Interfaccia Utente Grafica (GUI, Graphical User Interface) in cui l'utente interagisce con menù ed icone
Quindi, scopo di un sistema operativo è quello di:
 fornire un ambiente in cui un utente possa eseguire programmi
 rendere l’uso di un sistema di elaborazione conveniente
 eseguire funzioni non utili a se stesso ma fornire un ambiente entro il quale i programmi dell’utente possano produrre un lavoro utile: è simile a un
governante.

distribuire risorse. Un sistema di elaborazione ha tante risorse che possono essere richieste da un programma applicativo: CPU, memoria, file,
42 - Tecno1 rel. 17.03.17

dispositivi di I/O, Il S.O. ha la funzione di manager: le assegna ai programmi che ne fanno richiesta, in base a determinati criteri (politiche di gestione).
controllare l’esecuzione dei programmi utente per prevenire eventuali errori, ed evitare un uso improprio del sistema di elaborazione.
Ci sono due tipi distinti di sistemi operativi: sistemi operativi desktop e sistemi operativi di rete. I primi sono impiegati in piccoli uffici o in ambiente domestico.
Tra essi ricordiamo Microsoft Windows, uno dei sistemi operativi più popolari. Apple Mac OS progettato per essere un sistema operativo dalla interfaccia utente
grafica (GUI) facile da usare.
Le versioni correnti di Mac OS attualmente sono basate su una versione adattata di UNIX.
“Un sistema operativo per dispositivi mobili, in inglese "mobile OS", è un sistema operativo che controlla un dispositivo mobile con lo stesso principio con cui
Mac OS, Unix, Linux o Windows controllano un desktop computer oppure un laptop.
Tuttavia affronta problematiche legate alla natura del dispositivo mobile, più critiche rispetto ad un desktop o un laptop; tra le tante: la limitatezza delle risorse
(memoria, CPU), l'assenza di alimentazione esterna, differenti tecnologie per l'accesso a Internet (WiFi, GPRS, HSDPA...), nuovi metodi d'immissione
(touchscreen, minitastiere), ridotte dimensioni del display.” (Wikipedia)
Produttore
OS
Famiglia di sistemi operativi
Architettura CPU supportata
Linguaggio di programmazione
Apple
iOS
macOS/Unix-like
ARM
C, C++,Objective C
Google Inc.
Android
Linux
ARM/MIPS
C, C++, Java
Microsoft
Windows Mobile
Windows Phone
Windows CE 5.2/Windows NT
ARM
C++,C#
UNIX/Linux.
Unix è stato introdotto alla fine degli anni '60. Linux è stato sviluppato da Linus Torvalds nel 1991 come sistema operativo open-source. Oggo “il «pinguino» è
però arrivato in realtà ovunque. In settori dove Windows invece latita. Troviamo Linux sulla maggior parte dei server aziendali e nei cosiddetti supercomputer: 9
«cervelloni» su 10 dei top 500 ha il marchio del «pinguino». Che ora marcia anche nell’elettronica di consumo: dalle smart tv alle videocamere di Sony, sul Kindle,
sui cellulari e i tablet con Android. Rimane solo il nodo del fallimento sui desktop.”
Tipi di SO:
Multi-user – Due o più utenti possono lavorare contemporaneamente con i programmi e condividere le periferiche, come ad esempio le stampanti.
Multi-tasking e Multithreading– Il computer è in grado di eseguire più applicazioni (task, processi) contemporaneamente e un processo può essere suddiviso
in parti più piccole (thread) caricate dal sistema operativo.
Multi-processing – Il computer può avere due o più CPU (Central Processing Unit), condivise dai programmi.
I Sistemi Opertaivi di Rete (NOS) supportano più utenti, esegue applicazioni multi-utente, sono robusti e ridondanti e fornisce maggior sicurezza . Tra i sistemi
operativi di rete più comuni ricordiamo Windows Server 2003 e 2008.
43 - Tecno1 rel. 17.03.17
Evoluzione
Prima generazione (1945-1955)
Valvole e schede a spinotti
La macchina analitica (Analytical engine in lingua inglese) è stato il primo prototipo di un computer meccanico sviluppato per eseguire compiti generici. Il
progetto fu sviluppato dal matematico, filosofo e scienziato inglese Charles Babbage (1791–1871), che cercò anche di realizzarlo praticamente .
Prima di lui Pascal, nel 1642, aveva realizzato la pascalina, uno strumento di calcolo precursore della moderna calcolatrice. Lo strumento consente di addizionare
e sottrarre numeri composti da un massimo di dodici cifre, operando automaticamente i riporti.
In realtà la storia dei calcolatori moderni parte dalla metà del secolo scorso.
Verso il 1945, John von Neumann e altri scienziati riuscirono a costruire macchine da calcolo usando valvole elettroniche. Queste macchine erano enormi e
riempivano intere stanze con centinaia di migliaia di valvole. Uno dei primi calcolatori è stato l’ ENIAC del 1946 di US-Military che pesava circa 30 tonnellate!
EDSAC, J. Von Neumann
I primi computer non erano dotati di sistemi operativi. Non esistevano i linguaggi di programmazione ad alto livello, né l’assembly. L’utente disponeva di semplici
periferiche per posizionare i bit della memoria centrale, in modo da rappresentare istruzioni macchina e dati, e impostare il Program Counter. Il programmatore
si registrava su un foglio appeso al muro per un certo numero di ore; poi andava nella sala macchine, inseriva la propria scheda di spinotti con il programma nel
44 - Tecno1 rel. 17.03.17
calcolatore e passava le ore successive a sperare che nessuna delle circa 20000 valvole si bruciasse mentre il programma girava.
Inizialmente l’utente doveva operare direttamente in binario; in seguito si svilupparono le prime periferiche, in grado di leggere codici rappresentati su schede o
nastri perforati, per poi passare alle prime telescriventi che interagivano con la tastiera, la stampante. Furono così sviluppati i primi programmi di sistema per la
gestione di queste periferiche che diedero origine allo sviluppo dei sistemi operativi.
Il calcolatore era in grado di gestire un solo job (insieme di passi per la generazione di un programma) alla volta.
Seconda generazione (1955 – 1965)
Transistor e sistemi batch
L’evoluzione della tecnologia elettronica e l’avvento dei transistor durante la metà degli anni 50 del ‘900, cambiò radicalmente la situazione ( ).
Nel venne realizzata la prima unità a nastro magnetico e nel la iniziò a produrre in serie i transistor, mentre il primo computer totalmente transistorizzato fu del
1956. Sempre nel 1956 venne creato il primo .
Negli anni ‘50 fanno la loro comparsa anche i lettori di schede perforate per l’inserimento dei dati in memoria.
Sempre nel 1956 venne creato il primo
Risultò subito chiaro che le periferiche erano infinitamente più lente della velocità di esecuzione della CPU. Per questo nei successivi anni si cercò da un lato di
migliorare la velocità delle periferiche, dall’altro di sovrapporre nel tempo le operazioni di I/O e CPU agendo su BUFFER di memoria centrale che facevano da
tramite tra periferiche e Unità Centrale in cui la CPU poteva “pescare” o “scrivere” le informazioni di Ingresso e Uscita velocizzando le operazioni. Fanno la loro
comparsa anche i sistemi ad INTERRUPT in cui è la periferica a segnalare alla CPU il verificarsi di un evento.
In questo periodo i calcolatori venivano tenuti chiusi in speciali sale macchine con aria condizionata ed al loro funzionamento erano assegnati operatori
specializzati. Il sistema informativo era organizzato in modo da non prevedere l'uso di direttamente collegati con l'elaboratore centrale, l'unico modo che
consentiva di ottenere i servizi era quello di inviare al Centro le schede perforate con il programma da eseguire e , poi, di ricevere i risultati stampati. Tale
processo di elaborazione prendeva il nome di batch processing.
Job ( il job è un’applicazione che comprende codice, dati e istruzioni di controllo del job stesso), organizzati in gruppi omogenei (batch), cioè un Batch comprende
piu’ Job.
Un esempio:
$JOB user_spec
; identify the user for accounting purposes
45 - Tecno1 rel. 17.03.17






$FORTRAN
source program cards
$LOAD
$RUN
data cards
$EOJ
; load the FORTRAN compiler
$JOB user_spec
$LOAD application
$RUN
data
$EOJ
; identify a new user
; load the compiled program
; run the program
; end of job
Linguaggi assembly o ad alto livello
Sviluppo di programmi di sistema per la traduzione in linguaggio macchina
primi sistemi operativi per IBM 701, in grado di eseguire un job alla volta
Introduzione software di sistema sempre più potente non solo per gestione di periferiche, ma anche per gestire code di lavoro
Primi centri di calcolo
Gestione passa dai ricercatori al personale specializzato (operatori)
Nota: il termine batch o batch processing, viene utilizzato attualmente con vari significati che vanno dalla la non interattività dei programmi all’esecuzione di più
programmi accorpati, all'esecuzione non immediata nel tempo. O anche a programmi di script o comandi batch
Sistemi batch (a lotti)
. IBM 305 RAMAC (1956) è il primo computer con hard disk. Nel 1957 IBM rilascia il primo computer a transistor
Terza generazione (1965 – 1980)
Time sharing e multiprogrammazione. Circuiti integrati
“Dal momento che i primi erano estremamente costosi, non era possibile garantire l'accesso esclusivo ad un singolo utilizzatore per l'uso in modo interattivo. Dal
momento che con questa modalità di utilizzo i computer trascorrono molto tempo in attesa dell'input dell'utente, si pensò d i far utilizzare a più utenti lo stesso
elaboratore, utilizzando i tempi morti per servire i diversi utenti a rotazione . Allo stesso modo, le piccole porzioni di tempo che trascorrevano nell'attesa dei
dispositivi, quali , o potevano essere utilizzati per servire i vari utenti. I computer capaci di fornire servizi in time-sharing normalmente venivano impiegati per
lavori in durante la notte.” (wikipedia)
Multiprogrammazione: in grado di gestire contemporaneamente più job in memoria centrale, grazie al meccanismo della commutazione della CPU da un job
all’altro. Il S.O. fa in modo che la CPU si sospenda per tutto il tempo che un I/O resta inutilizzato e, riservandosi di riprendere il programma ad operazione di I/O
ultimata, passa all’esecuzione di un altro programma scelto tra quelli presenti nel Job Pool
La memoria centrale contiene i vari job e un algoritmo di SCHEDULAZIONE (CPU Scheduling = algoritmo per l’assegnazione della CPU) che sceglie il job da
mandare in esecuzione.
Nasce il problema della condivisione delle risorse da parte di più processi e dei relativi conflitti nell’assegnazione delle risorse del sistema: CPU, Memoria, I/O.
46 - Tecno1 rel. 17.03.17
VT52 - 1975

Spooling (simultaneous peripheral operations on line). E introdotto un disco come buffer intermedio tra il job e le stampati, affinché il job potesse
terminare più velocemente. Il lavoro memorizzato sul disco di spool veniva mandato in stampa quando la stampante era disponibili.
Spooling



Avvento dei DISCHI usati anche come buffer per lo SPOOLING. Dal TOS (Tape operanting System) al DOS (Disk Oparting System)
Monitor e terminali per seguire svolgimento di un job dalla complilazione all’output.
Time-sharing Ogni utente può dialogare attraverso un terminale ed eseguire programmi. I sistemi dovevano garantire tempi di risposta molto bassi ed un
grado di multiprogrammazione elevato:
o
I job prendono possesso a turno della CPU
o
o
o
o
o
o
Ogni job non verrà portato fino a termine (run to completion) ma avrà a disposizione la CPU per un tempo limitato
Se il tempo a disposizione è abbastanza breve e il cambio di job sufficientemente veloce si ha l’illusione di eseguire i job in parallelo
La CPU è usata a turno da diversi job
Un job viene spostato da disco a memoria e viceversa (swapping)
Il programma si sospende se:

È in attesa di una operazione della periferica

Ha finito il suo quanto di tempo (“time slice”)
Sistemi INTERATTIVI : un terminale permette di “interagire” con il computer per l’inserimento dei dati (i S.O. si evolvono anche in funzione
di alcune esigenze di mercato come, ad es., la prenotazione dei posti aerei
Nota: Agli inizi degli anni ’60, la maggior parte dei produttori di calcolatori aveva due linee distinte di prodotti incompatibili tra loro: grossi calcolatori scientifici
usati per calcoli numerici scientifici e ingegneristici, e calcolatori commerciali usati dalle ditte di assicurazioni e dalle banche.
47 - Tecno1 rel. 17.03.17
IBM introduce 360 costituito da una serie di macchine compatibili tra loro a livello sw. Differivano per prezzo e prestazioni ( velocità, memoria, numero di
dispositivi di I/O collegabili). Avevano però la stessa architettura e lo stesso insieme di istruzioni. Gli stessi programmi potevano girare su tutte le macchine.
Negli anni successivi IBM introduce i sistemi 370, 4300, 3080, 3090 tutti compatibili con 360.
360 fu il primo a usare tecnologia con circuiti integrati con vantaggi in termini di prezzo e prestazioni.
Quarta generazione (1980 – 1990 –> ai giorni nostri)
Ma un sistema di calcolo deve per forza costare milioni di dollari?
L’avvento della microelettronica con la realizzazione di chip a larga scala di integrazione consentì, a partire dal 1970, lo sviluppo dei minicomputer aprendo la
strada all’informatica distribuita.
Due SO hanno dominato la scena: MS-DOS e UNIX. L’evoluzione successiva fu segnata dal microprocessore, che consentì l’enorme diffusione dei calcolatori sia
come controllore di apparati, sia come cuore dei nascenti personal computer.
“Era il 12 agosto 1981 quando il suo IBM Personal
Computer (IBM 5150). Per molti anni non a caso si
parlò comunemente di “Pc Ibm” e poi di “Ibm compatibili” per definire tutti quei computer domestici basati su un processore Intel e con sistema operativo MsDos (che a sua volta ha da poco festeggiato i suoi 30 anni) prima e con Windows poi, dagli anni Novanta.
Apple 1 fu disegnata e progettata da Steve Wozniak nella Silicon Valley, e commercializzata più tardi proprio da Wozniak e Jobs attraverso una catena di
elettronica, Byte Shop, che comprò le prime 50 unità. Di questo modello furono in realtà realizzati solo 200 esemplari e oggi ne esisterebbero solo sei.
Sistemi Desktop
o
o
o
o
o
Personal computer (PC) sistema di calcolo dedicato ad un singolo utente
Periferiche di I/O evolute tastiere, mouse, schermi
Facilità d’uso e performance elevate
I S.O. per queste architetture adottano tecnologie sviluppate per S.O. potenti complessi; tuttavia spesso il PC è una macchina dedicata e
non sono necessarie tecniche sofisticate di gestione della CPU
Possono eseguire diversi tipi di sistema operativo(Windows, MacOS, UNIX)
Sistemi laptop/notebook
o
Uno dei primi laptop è stato il GRiD Compass 1101, utilizzato nelle missioni spaziali nei primi anni ottanta. Il suo peso era 5 Kg (11 lb) e il
costo US $8,000 - $10,000!. Il design compatto, la convenienza e l'evoluzione tecnologica dei notebook li stanno rendendo più convenienti,
sotto molti punti di vista, dei desktop. Infatti essi, oltre al basso peso, integrano wi-fi, ottimi schermi, prestazioni sempre più elevate, in
modo da essere molto richiesti per la loro comodità:

Prendere appunti o ricercare documenti.

Illustrare presentazioni.

Avere accesso da remoto

Giocare, guardare film, sentire la musica durante viaggi e spostamenti

Accedere a Internet e inviare e-mail in luoghi pubblici.
48 - Tecno1 rel. 17.03.17
Sistemi real-time
o
Spesso usati come strumento di controllo in una applicazione dedicata, come ad esempio controllo di esperimenti scientifici, sistemi di
visualizzazione in ambito medicale e sistemi di controllo industriale
o
o
o
o
o
Vincoli temporali fissati e ben definiti
Soft real-time (time critical) Il job terminerà molto probabilmente entro …
Hard real-time (life critical) Il job terminerà sicuramente entro …
Memoria secondaria limitata o assente
Dati memorizzati in memoria a breve termine o in memoria a sola lettura (ROM)
Sistemi multiprocessore (con più CPU comunicanti tra loro)
o
Vantaggi:

Maggiore throughput (capacità di elaborazione)

Risparmio economico

Maggiore affidabilità
Sistemi a cluster.
o
Il clustering permette a due o più sistemi di condividere periferiche (tipicamente dischi). Serve ad aumentare l’affidabilità
Sistemi operativi distribuiti
Ma per fare un sistema parallelo abbiamo per forza bisogno di mettere tutte le CPU nella stessa scatola ? NON necessariamente, anzi…
o
Il calcolo viene distribuito tra diversi processori fisicamente distinti
o
Vantaggi:

Condivisione delle risorse

Grande capacità di calcolo (distribuzione del carico)

Affidabilità

Comunicazioni
Sistemi distribuiti (paralleli) tightly coupled (strettamente connessi)
o
o
i processori condividono la memoria ed il clock
la comunicazione avviene solitamente attraversomemoria condivisa
Sistemi distribuiti loosely coupled (lascamente connessi o debolmente integrati). Reti
o
o
o
Ogni processore ha la sua memoria locale
I processori comunicano tra loro attraverso varie linee di comunicazione, come bus ad alta velocità o linee telefoniche
Richiedono un’infrastruttura di rete

Reti locali (LAN)

Reti metropolitane (MAN)

Reti geografiche (WAN)

Possono essere di due tipi

Client-server

Peer-to-peer (P2P)

Client-server. Il modello client-server presuppone l’esistenza di due entità:

Server (che eroga il servizio)

client (che richiede il servizio)
Una rete di computer o network è un insieme di computer - o un insieme di gruppi di computer - collegati tra loro per scambiare informazioni di vario tipo.
Le macchine collegate in una rete possono essere collocate a brevi distanze, in reti denominate LAN - Local Area Network - ma possono anche essere molto
distanti tra loro e connesse tramite reti di vaste dimensioni, in genere dette WAN - Wide Area Network - o reti geografiche, delle quali è un esempio Internet.
Internet è una rete di computer mondiale attraverso la quale milioni di utenti possono interagire a vari livelli e con diverse modalità.
La nascita di Internet può essere fatta risalire al 1969, ed è legata essenzialmente a ragioni militari. In quell'anno, infatti, sorse l'esigenza di connettere più
computer tra loro al fine di consentire la comunicazione alle basi militari sparse in tutto il territorio statunitense anche in caso di interruzione dei collegamenti
locali (si pensi a un conflitto nucleare). Nel 1990, Tim Berners Lee, ricercatore del CERN di Ginevra, propose la creazione di un sistema di reperimento
dell'informazione a livello mondiale per tenere in contatto tutti i ricercatori in campo fisico. In questo contesto e in questo periodo nacquero il World Wide Web e
il linguaggio HTML.
Negli anni immediatamente successivi, grazie all'avvento dei personal computer, cominciarono a entrare in rete anche le organizzazioni commerciali. Il fatto che
la rete non fosse più dedicata a scopi militari attrasse l'attenzione di utenti appartenenti a svariati mondi, tanto da portare alla nascita dell'attuale Internet, che è
ormai definibile come la Rete delle reti.
Il cloud computing
è un servizio che permette di archiviare ed elaborare le informazioni e sfruttare applicazioni e risorse software messe a disposizione da un fornitore di servizi in
Internet.
Da una parte c’è il fornitore che mette a disposizione dei servizi fruibili da qualsiasi luogo e in qualsiasi momento, dall’altro il cliente che accede da remoto ai
49 - Tecno1 rel. 17.03.17
servizi senza la necessità di disporre di risorse interne all’azienda ed eliminando, così, i costi dovuti all’infrastruttura, alla manutenzion, aggiornamento e
protezione dei sistemi.
Rispetto ai semplici servizi di virtualizzazione, il cloud computing offre il vantaggio del self serving ciè la possibilità di ottenere esclusivamente le risorse
necessarie su richiesta (on demand), pagando solo i servizi realmente utilizzati.
L’infrastruttura di un cloud è l’insieme di hardware e software che consente di fornire i servizi essenziali del cloud computing. Lo strato fisico include server,
storage e componenti di rete. Il livello software implementa i servizi essenziali del cloud
Sensori e MEMS
L’esigenza di rendere sempre più semplice e diretta la comunicazione tra macchina e persona unita all’evoluzione, complessità e miniaturizzazione dei dispositivi
elettronici sta imprimendo una nuova svolta nei sistemi di interfaccia tra l’uomo e la macchina.
In questo contesto attuatori e sensori svolgono un ruolo determinante. Sono essi, infatti, gli elementi che direttamente integrati nel silicio, fanno da tramite tra le
grandezze fisiche (temperatura, pressione, suoni, onde,...) e il sistema di elaborazione.
La tecnologia relativa a questi componenti è inziata negli anni sessanta del secolo scorso ma avuto una crescita esponenziale a seguito delle applicazioni delle
nanotecnologie.
Sensori
Le tecniche avanzate relative ai sensori permettono una miriade di possibilità. Esistono sensori di luce, come quelli per le fotocellule, o sensori di suono come i
microfoni, sensori di temperatura e di calore, per la rivelazione di elettricità, tensione e campi magnetici, sensori per la rilevazione di di radiazioni, come i
contatori Geiger o i dosimetri, sensori di pressione e rilevamento di gas, sensori di prossimità o sensori biologici che si basano su tessuti viventi. Sensori Wi-Fi e
RFID.
MEMS e IoT
La tecnologia Mems (Micro Electro Mechanical Systems), basata sulle nanotecnologie, consente di integrare in spazi ridottissimi, nello stesso componente,
funzioni elettroniche e meccaniche, oltre che ottiche, biologiche o chimiche.
Fondamentalmente, un dispositivo MEMS contiene, su un minuscolo chip di silicio, micro - circuiti integrati con dispositivi meccanico o sensori.
In questo modo è possibile disporre di sensori microelettromeccanici che comprendono sensori di pressione , umidità, microfoni, giroscopi , magnetometri,
accelerometri , bussole digitali , sensori per ultravioletti e sensori tattili .
Le applicazioni sono enormi.
Si va dai prodotti di consumo all’industria, all’automazione.
Usi interessanti si trovano nei cellulari, nei giochi e nella robotica dove si fa largo uso di giroscopi e accelerometri per determinare la posizione nello spazio del
sistema. Nelle videocamere è possibile compensare il movimento. Nei proiettori di nuova generazione si trovano applicazioni per la gestione di microspecchi.
In campo automobilistico i MEMS li troviamo sparsi ovunque: airbag, sistemi di navigazione assistita, scatole nere, antifurto.
Anche nel campo medicale i MEMS trovano vaste applicazioni. Ad esempio, vengono usati per il controllo della pressione oculare, oppure per il movimento degli
arti (fig. 1).
50 - Tecno1 rel. 17.03.17
Fig 1- I MEMS applicati al corpo umano.(ST Microelectronics )
Bruno Murari, è un pioniere della microlelettronica e, in particolare dei MEMS.
Dai primi anni sessanta del secolo scorso lavora alla, divenuta poi STMicroelectronics, Sgs di Agrate in cui si sperimentano i primi circuiti intergrati. Il lungo
lavoro nei laboratori lo porta, tra le altre cose, a interessarsi di segnali elettrici di potenza e delle testine di hard disk e stampanti.
Negli anni novanta nasce l'accelerometro che, per la prima volta, viene inserito nella consolle Wii della Nintendo realizzando un successo mondiale.
Sistemi embedded ( integrati)
Sistemi semplici che svolgono compiti specifici e danno priorità alla gestione dei dispositivi fisici. Computer presenti nelle automobili, lavatrici, e centraline di
allarme, bancomat …
Raspithon: http://moodle.isisfacchinetti.it/mod/data/view.php?d=21&rid=517
embedded systems are found in cell phones, digital cameras, camcorders, portable video games, calculators, and personal digital assistants, microwave ovens,
answering machines, home security systems, washing machines, lighting systems, fax machines, copiers, , and scanners, cash registers, alarm systems, automated
teller machines, transmission control, cruise control, fuel injection, anti-lock brakes, active suspension and many other devices/ gadgets.
CHARACTERISTICS
a) Embedded systems are application specific & single functioned; application is known a priori, the programs are executed repeatedly.
b) Efficiency is of paramount importance for embedded systems. They are optimized for energy, code size, execution time, weight & dimensions, and cost.
c) Embedded systems are typically designed to meet real time constraints; a real time system reacts to stimuli from the controlled object/ operator within the
time interval dictated by the environment. For real time systems, right answers arriving too late (or even too early) are wrong.
d) Embedded systems often interact (sense, manipulate & communicate) with external world through and actuators and hence are typically reactive systems; a
reactive system is in continual interaction with the environment and executes at a pace determined by that environment.
e) They generally have minimal or no user interface.
Nessuna macchina moderna può anche muoversi senza elettronica. Iniezione del carburante e ABS, sospensioni e cruise control adattivo, airbag o cambi
automatici - tutti questi sotto-sistemi sono controllati da un software altamente efficiente. Gli ingegneri si riferiscono qui a "sistemi embedded".
PDA, Cellulari, Sistemi Palmari e Videogiochi –
Gli assistenti digitali personali (PDA) sono costituiti da un di dimensioni contenute, tali da essere portato sul palmo di una , dotato di uno schermo tattile (o )). Il
PDA è un organizer personale elettronico con strumenti per organizzare le informazioni: Agenda , Calcolatrice, Sveglia, Accesso a Internet, Sistema GPS,
televisione, giochi, lettura... Lo smartphone è un telefono cellulare con funzionalità di PDA. Gli smartphone uniscono le funzioni di un telefono cellulare e quelle
di un computer in un unico dispositivo palmare. Le tecnologie dei PDA e degli smartphone continuano a fondersi tra loro.

iPhone è un prodotto da , Il dispositivo, oltre ai normali servizi di telefonia, permette di utilizzare servizi come e-mail, navigazione web, . Viene controllato
dall'utente tramite uno schermo , un sensore di movimento del dispositivo, una tastiera virtuale. L'interazione con l'utente è coadiuvata da un sensore di
prossimità e un sensore di luce ambientale
51 - Tecno1 rel. 17.03.17
i-phone
Nota: sensori: “con il termine sensore si definisce un dispositivo che trasforma una che si vuole in un segnale
di natura diversa (tipicamente elettrico) più facilmente misurabile o memorizzabile.” Esistono moltissimi tipi di
sensori: ad es. di luce (o sensori ottici)come le fotocellule , i sensori di suono come i microfoni, i sensori di
temperaturacome i termometri e le termocoppie, i sensori di movimento come i radar, i velocimetri o i
tachimetri, di posizione come i giroscopi…

L'iPad è un tablet computer prodotto da Apple in grado di riprodurre contenuti multimediali e di navigare su Internet. Si tratta di un dispositivo un
dispositivo a metà strada tra un telefono cellulare evoluto e un computer portatile. E’ dotato di uno schermo da 9,7 pollici, con retroilluminazione a LED e
supporto al multi-touch. l'iPad è in grado di eseguire solo software scaricati dall'App Store. L'iPad include Safari (browser), iPod, iTunes Store, App Store, Maps,
Note, Calendario e Contatti.
“L'architettura ARM (Acorn RISC Machine) indica una famiglia di a sviluppata da e utilizzata in una moltitudine di . Grazie alle sue caratteristiche di basso consumo
elettrico (rapportato alle prestazioni) l'architettura ARM domina il settore dei dove il risparmio energetico delle è fondamentale” (Wikipedia). ARMv8-A introduce
un’architettura a 64-bit.
La famiglia ARM
“L'architettura ARM (precedentemente Advanced RISC Machine, prima ancora Acorn RISC Machine) indica una famiglia di a sviluppata da e utilizzata in una
moltitudine di sistemi . Grazie alle sue caratteristiche di basso consumo (rapportato alle prestazioni) l'architettura ARM domina il settore dei dispositivi mobili
dove il risparmio energetico delle batterie è fondamentale.
Attualmente la famiglia ARM copre il 75% del mercato mondiale dei processori a 32 bit per applicazioni embedded, [1] ed è una delle più diffuse architetture a 32
bit del mondo. I processori ARM vengono utilizzati in , , , lettori multimediali, videogiochi portatili e periferiche per computer (come , di rete ecc). Importanti rami
della famiglia ARM sono i processori e i processori prodotti da . “
Approfondimenti ARM
Introduzione ARM

http://www.toves.org/books/arm/

http://www.dsi.unifi.it/~bucci/Teaching/Magistrale/Approfondimenti_ARM.pdf

http://www.uniroma2.it/didattica/eldig2/deposito/eldig2-esercitazione2.pdf
Simulatore Windows

http://armsim.cs.uvic.ca/DownloadARMSimSharp.html
Progetto simulatore online

https://github.com/dhammika-marasinghe/arm-sim (vedi anche esempi https://github.com/dhammika-marasinghe/arm-sim/tree/master/examples)
Emulator online

https://tesla.ce.pdn.ac.lk/arm/arm2/
ARMDROID:

https://tesla.ce.pdn.ac.lk/arm/armdroid/

https://salmanarif.bitbucket.io/visual/
examples

http://www.cse.uaa.alaska.edu/~ssiewert/a225_doc/ARM_ASM_EXAMPLES-from-UT.pdf

http://peterdn.com/post/e28098Hello-World!e28099-in-ARM-assembly.aspx
esempio
# ARM program to print "Hello World!"
# *************** instruction memory
.text
.global main
main:
# store(push) lr to the stack
sub
sp, sp, #4
str
lr, [sp, #0]
# your code here
ldr
r0, =hello
bl
printf
52 - Tecno1 rel. 17.03.17
# retrive(pop) lr from the stack
ldr
lr, [sp, #0]
add
sp, sp, #4
# return
mov
pc, lr
# *************** data memory
.data
hello: .asciz "Hello World!\n"
Console per videogiochi e realtà aumentata, virtuale, mixed
Wii (prodotta da Nintendo) fa largo uso di sensori e la sua caratteristica è il “controller senza fili, il Wiimote, simile ad un telecomando, che reagisce alle forze e
all'orientamento rispetto nello spazio attraverso un sistema di accelerometri e giroscopi presente al suo interno, e tramite un dispositivo ottico posto ad una delle
sue estremità interagisce con la barra sensore rendendo, inoltre, possibile il suo utilizzo come sistema puntatore sullo schermo TV.”
Microsoft Kinect è un accessorio per Xbox 360 sensibile al movimento del corpo umano senza l'uso di strumenti. Kinect è dotato di telecamera, doppio sensore
di profondità a raggi infrarossi composto da un proiettore a infrarossi e da una telecamera.
HoloLens di Microsoft analizza l’ambiente in cui ci troviamo e crea una «Mixed Reality», una realtà in cui delle figure realizzate con la luce (ologrammi)
interagiscono con le cose reali (muri, mobili, porte e finestre) intorno a noi. Lo strumento Microsoft si controlla con la voce (attraverso l’assistente Cortana) e con
i gesti delle mani, che le videocamere del visorevedono e interpretano.
53 - Tecno1 rel. 17.03.17
Struttura di un Sistema operativo
In pratica, il S.O. cosa deve fare?
Riuscire a gestire tutte le componenti da cui i sistemi di calcolo sono composti.
o
o
o
o
o
o
o
Gestore di processi (job)

Un processo è un programma in esecuzione. È costituito da:

Codice eseguibile

Uno stato (esecutivo)

Ogni processo necessita di risorse per portare a termine il proprio task:

CPU

memoria

accesso a file

I/O

Il sistema operativo si occupa di rendere disponibili le risorse ai processi ed è responsabile di tutte le attività legate alla loro
gestione:
o
Creazione e terminazione
o
Sospensione e ripristino
o
Sincronizzazione e comunicazione
Gestore della memoria

La memoria è condivisa da CPU e dispositivi di I/O. Il sistema operativo deve:

Tenere traccia di quali parti della memoria sono usate e da chi

Decidere, in caso di conflitto chi può accedere per primo

Decidere quali processi debbano essere caricati in memoria quando c’è spazio disponibile

Allocare e liberare zone di memoria in base alle richieste delle applicazioni
Gestore dei file

Un file è una raccolta d’ informazioni correlate e strutturate. I file possono rappresentare sia programmi che dati

Il sistema operativo è responsabile per:

Gestione di una organizzazione gerarchica (directory)

Creazione e cancellazione di file e directory

Spostamento dei dati da/verso dispositivi di memoria
Gestore del sistema di I/O

Un’interfaccia generale per i driver dei dispositivi
Gestore della comunicazione tra processi in ambito Sistemi Distribuiti

Non c’è condivisione di memoria

Usiamo una rete per le comunicazioni

La comunicazione avviene secondo un protocollo sia tra entità del sistema operativo, sia con entità esterne al sistema operativo
Interprete di comandi

La shell è un programma che attua l’esecuzione di operazioni, usando i comand del sietma opeartivo. Nel caso di Unix/Linux il
linguaggio comandi permette la scrittura di veri e propri algoritmi strutturati (script).
Politiche di protezione

La protezione si riferisce ad un meccanismo per controllare l’accesso al sistema e alle risorse di un utente da parte di
programmi, processi o altri utenti

Il meccanismo di protezione deve distinguere tra utente/processo autorizzato e non, specificare i controlli che devono essere
effettuati, fornire un modo per imporre dei criteri
- un esempio di gestione di sisteme di I/O Il sistema operativo genera, a partire dalla macchina hw, una gerarchia di macchine virtuali, ciascuna delle quali realizza i requisiti:
risolvere il problema dell’utilizzo delle risorse da parte di moduli di livello superiore
“moltiplicare” il numero dei dispositivi disponibili, accogliendo più richieste, gestite secondo determinate politiche di gestione (virtualizzazione CPU,
virtualizzazione memoria, spooling,…)
54 - Tecno1 rel. 17.03.17
Il modello onion skin
Il SO è come un letto: per dormirci sopra non basta il telaio! Inoltre il materasso è formato da tanti strati, ognuno con le sue funzioni.
Uno dei modelli proposti è il modello onion skin (H.M.Deitel 1983), che rappresenta il Sistema Operativo (Operating System, OS) come una successione di strati
costruiti sopra un nocciolo costituito dall’hw, ciascuno dei quali rappresenta una macchina virtuale.
Il modello onion skin del sistema operativo (Operating System - OS)
Primitiva = Ogni procedura standard per mezzo della quale il modulo mette a disposizione i servizi
Modulo = è una collezione di routine che attivano i meccanismi fisici necessari per risolvere problemi logici di uno stesso tipo (per es. Le operazioni di i/o o la
gestione della memoria)
Ciascuno strato costituisce un modulo, composto da programmi che vedono solo le procedure implementate dagli strati sottostanti, attraverso le primitive che
queste mettono a disposizione. Le primitive di ciascun modulo possono essere invocate solo dai moduli di livello superiore.
Gli strati sottostanti vengono visti come un oggetto unico. I livelli più bassi sono quelli più vicini all’hardware, quelli più alti sono vicini all’utente e alle sue
applicazioni.
I moduli sono tutti i programmi che costituiscono un livello scritti per risolvere una classe di problemi. Ogni modulo si può vedere come una scatola che contiene
al suo interno le competenze per risolvere un problema e presentare risultati in conseguenza dell’elaborazione di richieste. Quello che avviene all’interno di un
modulo non importa a chi richiede il servizio; esso può essere modificato o riscritto, a patto che non vengano modificate le procedure per accedervi.
Esempio:
telefonata. La procedura standard consiste nel sollevare la cornetta, attendere il segnale e comporre il numero; il modo in cui la compagnia telefonica invia il
segnale (via terrestre, satellite, ponte radio) non è rilevante per chi deve telefonare; ma se la compagnia modificasse la modalità di accesso al servizio, per
esempio imponendo di digitare un certo un certo numero di cifre segrete prima del numero, sarebbe molto difficile riuscire a telefonare.
La procedura standard è detta primitiva.
Un modulo allora è una collezione di routine che attivano i meccanismi fisici necessari per risolvere problemi logici di uno stesso tipo.
Per esempio due stampanti, corredate di rispettivi moduli di SO, possono diventare due dispositivi logici identici a condizione che i relativi moduli mettano a
disposizione le stesse primitive.
I moduli devono mantenere un alto grado di indipendenza; devono essere scritti senza conoscere la struttura interna degli altri moduli di SO.
Si consideri, ancora, ad esempio una delle operazioni piu’ comuni eseguite da un programma, come la lettura di informazioni presenti su disco. A livello di
processo utente la risorsa interessata è il file, mentre il linguaggio utilizzato è ad es. il C o il C++. Pertanto il linguaggio sfrutta una primitiva della seguente forma:
leggi ( nomefile, nomerecord)
Cio’ significa che l’utente non deve preoccuparsi di codificare nel proprio programma gli aspetti legati alla lettura fisica da disco che presuppongono domande del
tipo: dove si trova il file su disco fisicamente? Con quale meccanismo le informazioni sono estratte da disco? Esistono altri programmi che stanno utilizzando
questo stesso file? Come risolvere eventuali conflitti?
Questi problemi vengono affrontati dal livello sottostante di File System che puo’ comprendere, a sua volta, piu’ processi che servono a calcolare l’indirizzo fisico
55 - Tecno1 rel. 17.03.17
del disco su cui sono registrate le informazioni cercate.
Anche il File System ha pero’ una visione astratta della risorsa e si serve del livello sottostante di Gestione dell’ I/O. Tramite opportune primitive il File System
comunica al gestore di I/O che conosce nel dettaglio la periferica (Device Driver) l’operazione da compiere e questo provvederà ad effettuare le operazioni di I/O
necessarie al trasferimento delle informazioni da disco alla memoria centrale.
A questo punto il Gestore della Memoria Centrale (in cui tutti i processi devono risiedere per essere eseguiti) provvede a convertire gli indirizzi virtuali di ogni
processo in indirizzi assoluti.
Chi gestisce l’esecuzione dei processi è il Nucleo!
Alcuni programmi di SO interagiscono direttamente con le componenti hardware; questi quindi devono conoscere le caratteristiche degli specifici dispositivi, per
poterli controllare e adoperare.
Inoltre è opportuno che un SO possa accedere anche a dispositivi inizialmente non previsti.
Ad ogni dispositivo è associato un software: device driver (plug and play)
Un device driver scritto per un dispositivo anche simile, ma non uguale, può non funzionare. Si tende quindi a definire dispositivi compatibili tra loro, secondo
standard affermati che si impongono o vengono imposti in vari modi:



dominio sul mercato di una particolare azienda produttrice
normative erogate da istituti riconosciuti a livello internazionale (es ISO).
In seguito al lavoro di gruppi di ricerca costituiti da team di aziende concorrenti che impostano accordi per lavorare insieme nello sviluppo di nuovi
componenti e tecnologie.
56 - Tecno1 rel. 17.03.17
I PROCESSI
Un processo è un programma in esecuzione.
Un processo è un’attività sequenziale che si concretizza nell’esecuzione del codice di uno o più programmi, e che può essere eseguita “in parallelo” ad altri
processi. Ogni processo evolve nel tempo poiché cambiano i valori dei dati. Lo stato di un processo in un determinato istante è descritto dalla “fotografia”, in
quell’istante, di tutti i valori dei dati usati dal programma inclusi i valori del program counter, dei registri e delle variabili.
Programma: è un insieme di bit di codice (sezione codice) e di dati (sezione dati) allocati in ben precise posizioni di memoria durante l’esecuzione (entità passiva)
Processo: è una particolare sequenza di esecuzione delle istruzioni di un programma, porzione di programma, o insieme di programmi (entità attiva)
Consideriamo un cuoco che sta preparando una torta. Ha una ricetta e gli ingredienti necessari: farina, uova,…
La ricetta è il programma (l’algoritmo espresso in una notazione adeguata), il cuoco è il processore, e gli ingredienti della torta sono i dati in ingresso.
Il processo è l’attività che il cuoco svolge leggendo la ricetta, raccogliendo gli ingredienti e impastando e cuocendo la torta.
Immaginiamo che la figlia irrompa in cucina piangendo e dicendo di essere stata punta da un’ape.
Il cuoco segna il punto della ricetta a cui è arrivato (lo stato del processo in esecuzione viene salvato), prende il libro del pronto soccorso, e comincia a seguire le
indicazioni.
E’ un esempio di come il processore cambi contesto da un processo ad un altro a priorità più alta, ciascuno con un programma diverso (ricetta, libro pronto
soccorso). Quando il figlio sarà medicato, il cuoco riprenderà a cucinare la torta, dal punto in cui era rimasto.
Quindi:
Un processo è un programma in esecuzione ed è costituito da:

Codice eseguibile

Uno stato (esecutivo)
Ogni processo necessita di risorse per portare a termine il proprio task

CPU

Memoria

accesso a file

I/O
ll sistema operativo

Si occupa di rendere disponibili le risorse ai processi

È responsabile di tutte le attività legate alla loro gestione:
◦ Creazione e terminazione
◦ Sospensione e ripristino
◦ Sincronizzazione e comunicazione
Definizione di processo
Processo P = (C, S) => programma in esecuzione;
è formato da:

una sezione di testo (C) codice del programma (parte statica del programma che non varia nel tempo),

da uno stato di esecuzione (S) composto da:
◦ program counter
◦ valori dei registri della CPU
◦ stack con i dati relativi all’esecuzione
Il processo è qualcosa di dinamico, che varia nel tempo. Non va quindi confuso con il concetto di programma (statico, non in esecuzione, ossia l’insieme di codice
contenuto in un file nel supporto di massa); diverse istanze di uno stesso programma sono da considerare infatti diversi processi
Un processo è rappresentato nel sistema operativo da un descrittore di processo (PD = process descriptor, chiamato anche PCB = proccess control block ), che
contiene tutte le informazioni relative al processo stesso
Il processore è l’oggetto in grado di attuare le transizioni tra gli stati definiti dalle funzioni di transizione (cioè la macchina su cui gira il programma).
Il NUCLEO (Kernel) genera un processore virtuale per ogni processo
il termine processo è ormai universale, ma per la precisione:

lavoro (job) in caso di sistemi batch

processo in caso di sistemi time-sharing
57 - Tecno1 rel. 17.03.17
I processi in Windows
Descrittore di processo (PCB)
Come vengono rappresentati i processi nel sistema operativo?
Ad ogni processo viene associata una struttura dati (descrittore): Process Control Block (PCB)
Quando un processo si sospende, il suo stato deve essere salvato. Per far cio' si associa al processo un' AREA di memoria (struttura dati) il DESCRITTORE DI
PROCESSO (Process Control Block o Task Control Block) cosi' definito (almeno nei campi essenziali, che a seconda del linguaggi puo’ essere implementato in
modo diverso (ad ex. in MASM86 con DB, in C con una struct etc)
Il PCB contiene tutte le informazioni relative al processo:

Stato del Processo – Contenuto dei registri di CPU (PC, SP, IR, accumulatori, etc.)

Informazioni di scheduling (priorità, puntatori alle code, etc.)

Informazioni per gestore di memoria (registri base, limite, etc.)

Informazioni relative all’I/O (risorse allocate, file aperti, etc.)

Informazioni di accounting (tempo di CPU utilizzato, etc.) – ...
PCB
Puntore dinamico
Nome processo
Priorità
Program Counter
Registri …
Stack privato
Stato
Altro (ex memoria privata...)
Process control block – kernel data structure contaning process state (registers, stack pointer, program counter, priority, open files, …)
Il SO mantiene una tabella (array di strutture) chiamata tabella dei processi, con una riga per ogni processo, che contiene informazioni sullo stato del processo, il
suo PC, SP, l’allocazione di memoria, stato dei suoi file aperti, informazioni per lo scheduling e tutte le informazioni necessarie per salvare lo stato di un processo
quando questo deve essere sospeso e poi ripristinato.
58 - Tecno1 rel. 17.03.17
Interazioni tra processi
Per capire come scomporre i processi e studiarne la loro interazione vediamo l’esempio seguente.
Esempio: “ Il ragu’ di zio Paolo”
SEQUENZIALE
(successione delle operazioni strettamente deterministica,
cioè esiste un ordine di precedenza) un fuoco – una
pentola
- Far bollire la salsa
- far soffriggere la carne tritata
- dopo un minuto mescolare la salsa
- aggiungere sale alla carne
- dopo due minuti mescolare la salsa
- quindi aggiungere sale alla salsa
- continuare a mescolare la salsa ogni minuto finchè la
carne è cotta
- aggiungere la carne alla salsa
- continuare a mescolare il ragu’ finchè il tutto è ben
amalgamato,
- quindi togliere dal fuoco e servire
CONCORRENTE
(uso di due fuochi con due pentole)
Salsa
1. far bollire la salsa
2. dopo un minuto mescolare la salsa
3. dopo due minuti mescolare la salsa
4. quindi aggiungere sale alla salsa (*)
5. continuare a mescolare la salsa ogni
minuto finchè la carne è cotta (**)
6. continuare a mescolare il ragu’ finchè il
tutto è ben amalgamato, quindi togliere
dal fuoco e servire
carne
1. far soffriggere la carne tritata
2. aggiungere sale alla carne (*)
3. quando la carne è cotta aggiungerla alla
salsa (**)
Questi processi, in generale, non possono evolvere e in modo del tutto indipendente ma devono interagire ed essere sincronizzati. In particolare ci sono due tipi di
interazione:

COOPERAZIONE (sincronizzazione):
i processi sono logicamente connessi, cioè quando un processo, per evolvere, ha bisogno dei dati dell'altro

INTERFERENZA
I processi sono logicamente NON connessi e potrebbero ( e vorrebbero ) evolvere in odo indipendente ma non lo possono fare perche’ le risorse del sistema
(periferiche, memoria, files etc) sono in numero limitato vanno condivise"
NB. Le risorse di un sistema possono essere classificate come Condivisibili (Sharable) (cioè usabili da parecchi processi in contemporanea, ad ex,. un file a sola
lettura o un'area di memoria protetta) o NON Condivisibili (NON- Sharable) cioè il loro uso è riservato a un processo alla volta (ad ex. periferiche, file scrivibili,
aree dati modificabili etc)
Relazioni di precedenza
Si abbia ad ex : Un unico processo di questo genere:
Leggo 1
Eseguo 1
Scrivo 1
Leggo 2
Eseguo 2
Scrivo 2
Leggo 3
Eseguo 3
Scrivo 3
Si noti che Leggo2 deve essere eseguito dopo Leggo1 ma prima, durante o dopo Eseguo1 il quale deve precedere Scrivo I
Quindi potrei scomporre in modo diverso il processo in diversi processi a patto che questi rispettino le precedenze! Cosi' ad ex posso avere:
L1
L2 E1
L3 E2 S1
E3 S2
S3
Ma anche:
LI
L2
L3
E1
E2
E3
S1
S2
S3
In generale ci sono processi in cui le relazioni di precedenza tra le fasi non sono strettamente deterministiche quindi non sequenziali, ma è OPPORTUNO che le
funzioni siano SCOMPOSTE E RAGGRUPPATE in modo da ottenere PROCESSI SEQUENZIALI
Un processo quindi, è un processo sequenziale
59 - Tecno1 rel. 17.03.17
• La logica del problema non impone un ordinamento totale fra le operazioni da eseguire; ad esempio è indifferente che venga eseguito (2 + 3) prima di eseguire
(6 - 2) o viceversa.
• Entrambe le operazioni precedenti devono invece essere eseguite prima del prodotto dei loro risultati
• Certi eventi del processo sono tra loro scorrelati da qualunque relazione di precedenza temporale; il risultato dell’elaborazione è indipendente dall’ordine con
cui gli eventi avvengono
• Molti settori applicativi possono essere rappresentati da processi non sequenziali: sistemi in tempo reale, sistemi operativi, sistemi di simulazione, etc…
Esercizio: scomporre in processi (paralleli) la formula di risoluzione di una equazione di secondo grado implementazione di un processo (sequenziale)
Sistemi multiprogrammati
Scopo: ottimizzare l’utilizzo della CPU
Un sistema operativo è composto da un insieme di programmi che, per essere eseguiti dalla CPU, devono risiedere in memoria centrale (MC).
Deve però essere possibile eseguire anche almeno un programma utente. Un programma utente deve quindi condividere almeno la CPU e la MC con il sistema
operativo.
Un sistema è detto monoprogrammato quando la sua memoria centrale contiene, in un determinato istante, codice di un unico programma utente.
60 - Tecno1 rel. 17.03.17
Talvolta l’esecuzione di un’istruzione del Processo Utente (PU) comporta la chiamata di una routine di sistema, per esempio richiesta di I/O. Se il programma è
scritto in un linguaggio ad alto livello (C,..) sarà il compilatore a generare il codice appropriato per il SO, poiché le primitive usate dipendono dal SO.
In ogni caso il compilatore genera una sequenza di istruzioni, tra le quali ad un certo punto compare una chiamata al SO. In questo caso il PU deve essere
sospeso a favore del SO, previo salvataggio dello stato del processo. Il salvataggio dei registri, … garantisce il ripristino del processo a patto che l’area di memoria
usata non sia intaccata dalla routine di sistema. E’ riservata una determinata zona di memoria per i moduli del sistema, e i PU sono caricati in un’altra area di
memoria.
Quando il PU termina, la memoria è disponibile per l’esecuzione di un altro PU.
Si può dividere il tempo che intercorre tra l’inizio e la fine del programma in intervalli caratterizzati dalle diverse attività della CPU:



esecuzione di istruzioni del PU
esecuzioni di istruzioni del SO
inattività, per esempio, quando attende un input da tastiera.
Sia Tempo Totale = TempoUtente + Tempo Inattivo + Tempo Sistema

Tempo Inattivo può essere grande rispetto agli altri perché la CPU è molto veloce. In particolare in programmi interattivi;il tempo che intercorre tra
due battiture di tasti (decimi di secondo) è lunghissimo rispetto ai tempi di esecuzione della macchina (miliardesimi di secondo). Nel Tempo Inattivo la
CPU potrebbe eseguire istruzioni di altri programmi
Si tenga presente che, come ampiamente visto, è possibile sospendere l’esecuzione di un processo a favore di un altro, e poi riprendere l’esecuzione del
processo sospeso.
Conclusione: si potrebbe sfruttare maggiormente la CPU facendo in modo che, nel Tempo Inattivo, venga usata per eseguire un altro PU. In tal modo si ottiene
un uso più razionale della risorsa CPU. Anziché usare più CPU, si usa una sola CPU.
Un tale Sistema è detto multiprogrammato .
Per realizzare la multiprogrammazione occorre avere a disposizione meccanismi per:
decidere quale istruzione deve essere eseguita dopo quella in esecuzione (se dello stesso programma o di un altro)
protezione tra diversi programmi, per evitare che i dati di uno vengano inquinati con quelli di un altro.
Risolvere eventuali conflitti che possono sorgere per l’assegnazione di una determinata risorsa che può essere condivisa tra più processi.
Il SO deve intervenire periodicamente, non solo su richiesta di un PU: tutte le attività sopra descritte devono essere svolte dal SO; da ciò consegue che il Tempo
Inattivo recuperato, non sarà completamente utilizzato per eseguire istruzioni di PU, ma anche per eseguire routine del sistema (system overhead : carico di
lavoro imposto al sistema)
grafico dei processi A,B.C in un sistema MONOPROGRAMMATO: (===== rappresenta l’attività)
A
A
B
B
C
C
CPU ======.............======.======.............====== ======..............======
A
B
C
I/O ……….======.........…………...======............................======.............
A
======.............======...............
B
…………………………….======...............======..........................................
C
…………………………………………………………...======...............======....
- grafico degli stessi processi in un sistema MULTIPROGRAMMATO:
A
B
A
B
C
C
CPU =====.====== =====.====== ======..............======
A
B
C
I/O ……….======.======.........................======.............
A
======.............======...............
B
…………======.............======..........................................
C
………………………………………======...............======....
- grafico degli stessi processi in un sistema MULTIPROGRAMMATO con una schedulazione diversa:
A
B
C
A
B
C
CPU =====.====== =====.====== ======.======
A
B
C
I/O ……….======.=====.======.............
A
======...........…………..======...............
B
…………======..........…………..======..........................................
C
……………………======............………….======....
61 - Tecno1 rel. 17.03.17
Time sharing
Una risorsa viene gestita in time sharing quando il suo uso viene concesso al richiedente, per un tempo che non può superare un massimo: questo intervallo di
tempo viene chiamato time slice (quanto di tempo).
Se la CPU di un sistema multiprogrammato viene gestita in time sharing, essa rimane assegnata ad un Processo Utente fino a che non si verifica una delle
seguenti condizioni:



il Processo termina
il processo in esecuzione richiede I/O
scade il time slice
Quando si verifica uno di questi eventi il controllo della CPU passa al SO che “decide” a quale processo assegnare la CPU tra quelli che ne hanno fatto richiesta e
che sono pronti per andare in esecuzione.
Il tempo impiegato dal SO operativo per effettuare queste operazioni viene detto tempo di riassegnamento. (si verifica context switch).
Stati di un processo
Immaginiamo di entrare in un supermercato e studiare il comportamento della cassiera e dei clienti:
Notiamo alcune analogie:

Cassiera/Cassa: Unità Centrale di Elaborazione

Clienti: processi

Cliente (che sta pagando) alla cassa: in che stato è?

Clienti in coda alla cassa: in che stato sono?

Clienti in coda alla macchina del caffè/gelato/snack/verdura: in che stato sono?

Guardia giurata: schedulatore
Ora vediamo la macchina a stati del processo:
62 - Tecno1 rel. 17.03.17
- stati di un processo Esecuzione (run): il processo è in evoluzione; gli è stata assegnata la CPU
Pronto (ready) :attende che gli venga assegnata la CPU
Attesa (wait): avendo richiesto un’operazione di I/O, la CPU gli è stata tolta, ed il processo è in attesa su una periferica.
Passaggi di stato:
All’inizio il nuovo processo creato viene caricato in memoria e va nello stato di pronto
da pronto a esecuzione: la CPU viene assegnata al processo
da esecuzione a pronto: scade il time slice (o avviene una interruzione) e al processo viene tolta la CPU
da esecuzione a attesa: il processo richiede un I/O, la CPU gli viene tolta anche se non è scaduto il time slice
da attesa a pronto: l’operazione di I/O è terminata e il processo è inserito nella coda dei processi pronti per entrare in esecuzione
I passaggi da uno stato all’altro sono gestiti con interrupt sincroni o asincroni:

Cioè i processi possono sospendersi a causa di un evento esterno non prevedibile (un interrupt hardware o un timer che scade) : interrupt asincrono

Oppure sospendersi volontariamente , perché ad esempio, in attesa di una risorsa , tramite un interrupt sincrono (software), tipicamente realizzato
con una chiamata al sistema operativo (Interrupt Sincrono o Supervisor Call (SVC) o System Call).
http://lia.deis.unibo.it/Courses/sola0708-auto/materiale/2.Processi.pdf
63 - Tecno1 rel. 17.03.17
Il nucleo
Virtualizzazione CPU
In ambiente multiprogrammato con CPU gestita in time sharing, è possibile vedere la CPU come un insieme di processori virtuali assegnati ai processi. I tempi di
commutazione sono così veloci che sembra che ciascun processo abbia a disposizione un processore. In realtà questo è uno solo, ma corrisponde a tanti
processori virtuali che fanno avanzare i processi. I moduli esterni potranno contare su una pluralità di processori, senza occuparsi dei problemi inerenti
l’assegnazione della CPU o delle interruzioni.
Il nucleo (kernel) è la parte del SO più vicina alla macchina.
L'accesso diretto all'hardware può essere anche molto complesso. Il Sistema Operativo e , in particolare il Kernel, “nascondono” le complessità dell’hardware e
rendono la macchina “gradevole” all’utente.
Pur nelle loro differenze c'è un elemento strutturale che accomuna ogni sistema operativo – sia mobile sia desktop – oggi in uso: il kernel (“nocciolo” o “fulcro in
inglese). Naturalmente, ognuno dei sistemi operativi (Windows, Android, iOS, Mac OS, …) ha un proprio kernel, realizzato in base alle necessità del sistema
operativo stesso. Per funzionare, però, tutti hanno bisogno di questo componente.
Utilizzando varie modalità di gestione – tra le quali la e le – il kernel fa da ponte tra le componenti hardware di un computer – come processore, RAM e hard
disk – e i programmi in esecuzione sul computer stesso. Data la sua rilevanza, è il primo programma ad essere caricato in memoria quando si accende un
computer e l'ultimo ad essere chiuso in fase di spegnimento. (cfr. Wikipedia e altre fonti in rete)
NOTA : Il kernel
I kernel implementano uno o più tipi di astrazione dall'hardware, il cosiddetto: . Queste astrazioni servono a
"nascondere" la complessità e a fornire un'interfaccia pulita ed uniforme all'hardware sottostante, in modo da
semplificare il lavoro degli sviluppatori.
I kernel si possono classificare - in base al grado di astrazione dell'Hardware - in almeno tre categorie (vedi
figura sottostante):
Kernel monolitici, che implementano direttamente una completa astrazione dell'hardware sottostante.
Microkernel, che forniscono un insieme ristretto e semplice di astrazione dell'hardware e usano software
(chiamati o ) per fornire maggiori funzionalità.
Kernel ibridi (o microkernel modificati), che si differenziano dai microkernel puri per l'implementazione di
alcune funzioni aggiuntive al fine di incrementare le prestazioni.
Compiti principali:



avvio e terminazione dei processi
assegnazione CPU ai processi
sincronizzazione tra processi
Tra le altre comprende le procedure per determinare a quale processo assegnare la CPU secondo determinate politiche di scheduling.
64 - Tecno1 rel. 17.03.17
Scheduler – Algoritmi di scheduling
Quando più di un processo è pronto per essere eseguito, il SO deve decidere a quale, tra i processi pronti, assegnare la CPU.
La parte di SO che si occupa di questa decisione viene chiamata scheduler (schedulatore), e l’algoritmo che usa è chiamato algoritmo di scheduling.
Lo Scheduler della CPU (“a breve termine”): è quella parte del S.O. che seleziona dalla coda dei processi pronti il successivo processo al quale assegnare l’uso
della CPU.
Lo scheduler è legato al tipo di politica adottato e non al meccanismo utilizzato per attuare tale politica.
I criteri secondo i quali è valutata la bontà di uno scheduler possono essere classificati nel seguente modo:
equità: assicurare che ciascun processo ottenga la CPU
efficienza: sfruttamento ottimale della CPU
livello di multiprogrammazione: numero di programmi in memoria
Throughput: numero di lavori processati nell’unità di
oppure throughput = TempoUtente / TempoTotale )
tempo
(throughput
=
numero
processi
eseguiti
/
TempoTotale
I tempi:
tempo di attesa : tempo per entrare in esecuzione
tempo di completamento (turnround time): intervallo di tempo tra inizio di un processo e la sua fine
overhead di sistema: tempo esecuzione del sistema operativo a scapito dei programmi utente.
CPU burst: tempi in cui viene impiegata soltanto la CPU senza I/O (al contrario di I/O burst: fasi in cui il processo effettua input/output da/verso una
risorsa(dispositivo) del sistema)
I meccanismi di scheduling:

preemptive se sospendono d’autorità un dato processo

non preemptive se consentono l’esecuzione di un processo sino in fondo. Questi sono semplici e facili da implementare, ma non sono adatti ai
sistemi multiutente. Esistono però sistemi dedicati, per esempio database, in cui è necessario fare iniziare un processo su una richiesta e non
interromperlo finché non completa la sua esecuzione.
Terminologia:
Ogni processo alterna:

CPU burst: fasi in cui viene impiegata soltanto la CPU senza I/O

I/O burst: fasi in cui il processo effettua input/output da/verso una risorsa(dispositivo) del sistema (burst = raffica)
Processi I/O bound: prevalenza di attivita` di I/O: molti CPU burst di breve durata, intervallati da I/O burst di lunga durata (bound=legato,confinato)
Processi CPU bound: prevalenza di attivita` computazione: CPU burst di lunga durata, intervallati da pochi I/O
Lo scheduler decide a quale processo assegnare la CPU. A seguito della decisione, viene attuato il cambio di contesto (context-switch).
Dispatcher: è la parte del S.O. che realizza il cambio di contesto.
http://lia.deis.unibo.it/Courses/SOA0405/lucidi/6.schedulingCPU4.pdf
First Come First Served (FCFS)
65 - Tecno1 rel. 17.03.17
Il primo processo che richiede la CPU è il primo ad essere servito
Svantaggio: non distingue tra processi che hanno interattività e processi che invece non ne hanno. Il tempo di risposta non è dei migliori. Il tempo di
completamento (turnround) è variabile.
Esempio 1 determinare il tempo medio di completamento :
dati tre processi A;B;C, il tempo di esecuzione è Ta=30, Tb=55, Tc=5,


se i processi vengono eseguiti nell’ordine A B C:
o
il tempo medio di completamento risulta 68 (30+85+90)/3,
se vengono eseguiti C;A;B allora
o
tempo medio di completamento è 43 (5+35+90)/3
Esempio 2 determinare il tempo medio di attesa :
Nota: Un diagramma di Gantt permette la rappresentazione grafica di un calendario di attività, utile al fine di pianificare, coordinare e tracciare specifiche dando
una chiara illustrazione dello stato d'avanzamento delle attività rappresentate
Round Robin (RR)
A ciascun processo è assegnato un quanto di tempo, durante il quale il processo è posto in esecuzione. Se il processo non è ancora terminato prima della fine
del quanto, gli viene tolta la CPU ed assegnata ad un altro processo. Se termina prima che il suo quanto scada, la commutazione della CPU avviene quando il
processo termina.
L’implementazione di questa politica richiede allo scheduler di mantenere una lista di processi eseguibili (stato di pronto). Allo scadere del quanto di tempo, il P
è posto nella coda dei processi pronti (coda di Ready).
Particolare importanza assume il dimensionamento del quanto di tempo:

se troppo breve => continua commutazione dei processi, abbassamento efficienza CPU, impegnata per lo più ad effettuare commutazioni di contesto
tra i processi

se troppo lungo => non adatto nel caso di richieste brevi; inoltre i P in attesa restano molto tempo fermi (non va bene nei sistemi interattivi)
Compromesso: 10-100 msec.
P1
P2
P3
P1
P2
P1
P1
P3
P2
Fine time slice
Tempo di riassegnamento
Richiesta I/O
Fine I/O
P3
Fine I/O
P2
Fine P3
Lo scheduler RR è molto usato in sistemi time-sharing per assegnare il processore ai processi in competizione. Il principio di funzionamento di questa tecnica è il
seguente: un P entra nel sistema collegandosi a una coda gestita con politica FIFO detta coda di ready. Ogni volta che un processo raggiunge la testa della coda,
questo viene eseguito per un intervallo di tempo predeterminato detto quanto. Se il processo non completa la sua esecuzione nel suo quanto, viene reinserito
nella coda di ready.
66 - Tecno1 rel. 17.03.17


Vantaggi: di RR sono la sua semplicità e il basso carico di lavoro nel prendere la decisione.
Svantaggi: se tutti i p sono CPU-bpound (un processo è detto CPU bound se compie principalmente computazioni e usa occasionalmente dispositivi di
I/O), il sistema si comporta equamente con ogni P, ma se è costituito da P sia CPU bound, sia I/O bound, è preferibili comportarsi in maniera differente
a seconda del tipo di processo, per evitare di privilegiarne uno a danno di altri. (VRR)
Esempio : cosa capita al variare del quanto di tempo? Il tempo medio di completamento varia in funzione del quanto di tempo.
Esempio con più processi:
P1=6 unità temporali, P2=3, P3=1 e P4=7:
quanto di tempo =2 -> T medio completamento = 14+10+15+17/4 = 11,5
quanto di tempo =3 -> T medio completamento = 13+6+7+17/4 = 10,75
quanto
tempo
di
Tempo medio di
completamento
1
11
2
11,5
3
10,75
4
11,5
5
12,25
6
10,5
7
10,5
(cfr Sistemi Operativi - Silberschatz , Galvin, Gagne - )
Shortest job first
Consiste nell’assegnare la CPU al job più corto. Questo permette di ottimizzare il tempo di turnround. Ad esempio siano A;B;C tre job con tempi di esecuzione
10,6,4 unità di tempo rispettivamente. Se venissero eseguiti nell’ordine A;B;C il tempo di turnround sarebbe: 10 per A, 16 per B, 20 per C, per un tempo medio di
15 unità ca.
Se vengono eseguiti nell’ordine C,B,A, i tempi di t saranno 4,10,20 con una media di 11 unità.
A_____________________10 10+
B____________6 16+
C________4 20= 46 /3 ≈ 15
C________4 4+
B____________6 10+
A_____________________10 20= 34 / 3 ≈ 11
Meccanismo di priorità
67 - Tecno1 rel. 17.03.17
codice pronto soccorso
A ciascun processo è assegnata una priorità; la CPU è assegnata al Processo (P) pronto con più alta priorità. Per evitare che un Processo possa essere eseguito
indefinitamente, lo scheduler può diminuire la priorità del P corrente ad ogni colpo di clock. In questo modo se il livello di priorità scende al di sotto di quello del
P successivo a priorità più alta, avviene la commutazione.
La priorità può essere definita in modo statico o dinamico.
Il meccanismo di priorità può essere combinato con quello Round Robin; si raggruppano i processi in classi di priorità e si adotta lo schema delle priorità tra le
varie classi, e la politica RR all’interno di ciascuna classe
Es
Priorità 4
Priorità 3
Priorità 2
Priorità 1
Finché ci sono P eseguibili nella coda di priorità 4, ciascun P viene eseguito per il proprio quanto. Se la coda di pr 4 si svuota, allora vengono eseguiti i P della
coda 3 RR, e così via. Se le pr non vengono modificate di volta in volta, le classi a priorità bassa possono non essere mai eseguite.
Aging (invecchiamento): aumento graduale della priorità dei processi che si trovano in attesa nel sistema da lungo tempo.
Un modo per realizzare l’aging è Highest Response Ratio Next scheduling uno Scheduling senza prelazione a priorità variabile.
La priorità è funzione di: Tempo di attesa e Tempo di burst
P = 1 è la minima priorità
T attesa: favorisce i processi che hanno già atteso molto
T burst: favorisce i processi corti
Thread
Il concetto di processo è associato a quello di thread (abbreviazione di thread of execution, filo dell'esecuzione), con cui si intende l'unità granulare in cui un
processo può essere suddiviso, e che può essere eseguito in parallelo ad altri thread.
Il multithreading è, quindi, una tecnica che permette di avere più flussi di esecuzione contemporanei (thread) di uno stesso programma in esecuzione, su CPU
differenti o sulla stessa.
In altre parole, un thread è una parte del processo che viene eseguita in maniera concorrente ed indipendente internamente al processo stesso.
Il termine inglese rende bene l'idea, in quanto si rifà visivamente al concetto di fune composta da vari fili attorcigliati: se la fune è il processo in esecuzione, allora
i singoli fili che la compongono sono i thread.
• Un processo ha sempre almeno un thread (se stesso), ma in alcuni casi un processo può avere più thread che vengono eseguiti in parallelo.
Una prima differenza fra thread e processi modo con cui essi condividono le risorse:
• i processi sono di solito fra loro indipendenti, utilizzando diverse aree di memoria interagendo soltanto mediante appositi meccanismi di comunicazione messi a
68 - Tecno1 rel. 17.03.17
disposizione dal sistema
• i thread tipicamente condividono le medesime informazioni di stato, la memoria ed altre risorse di sistema.
• Il processo è l'oggetto del sistema operativo a cui sono assegnate tutte le risorse di sistema per l'esecuzione di un programma,tranne la CPU.
• Il thread è l'oggetto del sistema operativo o dell'applicazione a cui è assegnata la CPU per l'esecuzione.
In un sistema che non supporta i thread, se si vuole eseguire contemporaneamente più volte lo stesso programma, è necessario creare più processi basati sullo
stesso programma.
Tale tecnica funziona, ma è dispendiosa di risorse, sia perché ogni processo deve allocare le proprie risorse, sia perché per comunicare tra i vari processi è
necessario eseguire delle relativamente lente chiamate di sistema, sia perché la commutazione di contesto tra thread dello stesso processo è più veloce che tra
thread di processi distinti.
Avendo più thread nello stesso processo, si può ottenere lo stesso risultato allocando una sola volta le risorse necessarie, e scambiando i dati tra i thread tramite
la memoria del processo, che è accessibile a tutti i suoi thread.
Avendo più thread nello stesso processo, si può ottenere lo stesso risultato allocando una sola volta le risorse necessarie, e scambiando i dati tra i thread tramite
la memoria del processo, che è accessibile a tutti i suoi thread.
Elementi per ogni Thread
Elementi per ogni Processo
•Program counter
•Stack
•Insieme dei registri
•Thread figli
•stato
•Spazio degli indirizzi
•Variabili globali
•File aperti
•Processi figli
•…..
Il multithreading permette di suddividere il lavoro in modo efficiente, ma introduce una complessità legata alla sincronizzazione tra i vari thread.
Un esempio di applicazione che può far uso di più thread è un browser Web, che usa un thread distinto per scaricare ogni immagine in una pagina Web che
contiene più immagini.
Un altro esempio è costituito dai processi server, spesso chiamati servizi o daemon, che possono rispondere contemporaneamente alle richieste provenienti da
più utenti.
L'architettura di una applicazione basata su un unico processo non funziona bene in un server di applicazioni Web. Se un utente con un Browser in Hawaii visita
una pagina del tuo sito Web, il server inizia a processare la richiesta. Se poi arriva la richiesta di un altro utente dalla Nuova Zelanda, esso deve aspettare fino a
quando la richiesta anteriore non si sia conclusa.
Una possibile soluzione a questo problema è avere molteplici processi che rispondano a queste richieste in modo tale che siano soddisfatte in un modo più o
meno simultaneo. Questo è ciò che fanno i CGI (ogni CGI crea un nuovo processo che a sua volta crea una pagina, dopodichè finisce). Tuttavia, ciò porta ad un
uso eccessivo delle risorse ed è inefficiente.
La priorità in Windows
Windows 2000 (con i suoi successori) dispone di uno scheduling dei processi (piu’ precisamente dei thread) servendosi di un algoritmo preemptive e a priorità.
La parte del nucleo che si occupa della schedulazione si chiama dispatcher.
Vengono sempre eseguiti i thread a priorità piu’ alta . Essi vengono interrotti se terminano, esauriscono il loro quanto di tempo , richiedono un I/O, oppure deve
essere mandato in esecuzione un thread a priorità piu’ alta: se un thread real-time entra nella coda dei processi pronti il processo a bassa priorità in esecuzione è
soggetto a prelazione (preemptive). Tuttavia Wndows2000 non è un S.O. real time : infatti NON garantisce un tempo prefissato entro cui il processo ad alta
priorità possa entrare in esecuzione.
Come mostrato in figura, il dispatcher impiega uno schema con diverse priorità, percorrendo l’insieme delle code da quella a priorità maggiore alla minore , fino a
trovare un thread pronto per l’ esecuzione. Se nessun thread è presente nelle code il dispatcher fa eseguire un thread speciale , di attesa, l’idle thread.
In Windows, ad ogni processo viene assegnata una delle seguenti quattro possibili classi di priorità :

IDLE_PRIORITY_CLASS>
o
usata per le applicazioni che devono andare in esecuzione quando il sistema non ha nient’altro da fare un esempio classico è lo screen
69 - Tecno1 rel. 17.03.17



saver
NORMAL_PRIORITY_CLASS
o
è la classe di default usata nella maggior parte delle applicazioni utente
HIGH_PRIORITY_CLASS
o
usata per quei processi che non possono essere interrotti durante la loro esecuzione e che svolgono la loro elaborazione in un tempo molto
ridotto che non pregiudica l’avanzamento dei processi a priorità inferiore usata dai processi di sistema
REAL_TIME_PRIORITY_CLASS
o
serve generalmente quando degli eventi devono essere elaborati immediatamente non appena si verificano non è consigliabile usarla
perché rallenta notevolmente i processi di sistema che gestiscono l’input dal mouse e della tastiera disco usata nei sistemi real time
La priorità in Linux
Linux dispone di due tipi di algoritmi di scheduling:

uno, equo, a partizione di tempo con diritto di prelazione;

un altro, progettato per il tempo reale, in cui le priorità sono piu’ importanti dell’equità.
Linux permette la prelazione dei soli processi eseguiti in modo utente, mentre un processo del nucleo non è soggetto a prelazione anche se un processo ad alta
priorità lo richiede.

processi a partizione di tempo. In questa classe Linux adotta un algoritmo basato sui crediti: quando occorre assegnare la CPU viene scelto il processo
col numero maggiore di crediti.
Ad ogni time slice il processo perde un credito.
Quando raggiunge lo zero, il processo viene sospeso e un altro subentra al suo posto.
Se tutti i processi hanno zero crediti, il SO procede a una rassegnazione dei crediti che tiene conto della priorità del processo aggiungendone ad ogni
processo nel sistema, e non solo a quelli eseguibili, i crediti secondo la formula:
crediti_nuovi= crediti_precedenti/2 + priorità

Processi in tempo reale (real time). La situazione è ancora piu’ semplice: esistono le due classi FCFS e RR. Ad ogni processo è assegnata una priorità.
Viene mandato in esecuzione (secondo RR o FCFS) il processo a priorità maggiore e, a pari priorità, quello che attende da maggior tempo. Anche in
Linux il real time è “debole” perché non c’è alcuna garanzia sul tempo in cui un processo in pronto venga mandato in esecuzione.
Tratto da : Introduzione ai sistemi real time Di GianLuca DeMichelis
Il comando nice (nice [OPTION] [COMMAND [ARG]...]) consente di dare una maggiore o minore priorità di esecuzione: la priorità può essere modificata da
nice nel range [-20, 19], -20 è la più alta priorità (massima precedenza di esecuzione), mentre 19 è la più bassa. Ad esempio :
$ nice -n 5 ~/bin/longtask
Esempio:
nice -n 15 nano
Nota: I valori da asegnare sono limitati dal seguente intervallo 19 e -20
Utillizando un valore negativo si aumenta la priorità del processo
Utilizzando un valore positivo si diminuisce la priorità del processo
L'utente normale puo utilizzare soltanto i valori positivi in quanto non ha i permessi per poter utilizzare i valori negativi.
Soltanto l'amministratore puo aumentare la priorità di un processo.
Il comando nice può essere utilizzato soltanto per avviare il processo , nel caso il quale si desidera cambiare la priorità durante l'esecuzione
si può utilizzare il comando renice
70 - Tecno1 rel. 17.03.17
Processi sequenziali e concorrenti
Corse critiche, Interferenza e Cooperazione
Spesso i processi non possono evolvere in modo del tutto indipendente, ma devono essere sincronizzati per garantire un perfetto funzionamento del sistema.
In particolare, si dice che più processi interferiscono tra loro quando, da un punto di vista logico, potrebbero evolvere in modo indipendente se non dovessero
usufruire della stessa risorsa.
Si dice che due processi cooperano quando sono logicamente interconnessi, cioè quando, per evolvere, uno dei due deve usare una risorsa che viene prodotta
dall’altro.
I programmi associati ai processi dovranno contenere apposite istruzioni (primitive) per la loro sincronizzazione e per la produzione e lo scambio di messaggi.
Le Corse Critiche sono situazioni in cui due o più processi leggono o scrivono dati condivisi. In questo caso il risultato dell’elaborazione dipende dall’ordine di
schedulazione dei processi.
La sequenza delle operazioni che possono portare a corse critiche è detta sezione critica.
Per evitare che si verifichi il problema i due processi non possono entrare contemporaneamente nella stessa Sezione Critica.
Esempio spooler di stampa
PA e PB condividono due variabili : in che punta al prox elemento libero, out che punta al primo elemento da stampare. Ci troviamo in questa situazione che
rappresenta l’occupazione di memoria. “Simultaneamente” PA e PB decidono di stampare:
0

1

2

3

4

5

6

7
8
9
Caso sfortunato:

PA legge in e trova che il prossimo elemento libero è 7, cosi’ assegna ad una var prox_libero_a :=7
Interrupt (ad esempio scade il time slice):

SO toglie CPU a PA.

SO assegna CPU a PB.

PB legge in (non ancora modificata da PA) e assegna ad una var prox_libero_b :=7, Inserisce il nome del file da stampare nell’item 7,
in := prox_libero_b +1, prosegue nella sua esecuzione
0

1

2

3

4

5

6

7
File PB
8
9


SO assegna CPU a PA.
PA
riprende da dove
in:= prox_libero_a +1, Prosegue
0
1
2
3
4
5
6
era
stato
interrotto.
Inserisce
il
nome
del
file
da
stampare
nell’item
7
(prox_libero_a)







71 - Tecno1 rel. 17.03.17
7
8
9
File PB
0
1
2
3
4
5
6






7
8
9

File PA
Formalmente non ci sono errori per quanto riguarda la gestione dei file da stampare, ma il file del processo B non sarà mai stampato!
Un problema analogo è quello della prenotazione , da parte di due utenti, di un posto aereo con la richiesta fatta, in contemporanea, a due operatrici diverse che
controllano i posti disponibili sull’aereo e ne danno conferma al cliente.
Sezioni critiche – Mutua esclusione
Studiamo un altro esempio riguarda il caso di due processi che possono allocare e deallocare dinamicamente aree di memoria centrale, di grandezza predefinita,
mediante due primitive Alloc e Dealloc:
ALLOC(ptr);
DEALLOC(ptr);
ptr  stack(top);
top  top+1;
top  top-1;
stack(top)  ptr;
Si noti che top è una locazione di sistema , condivisibile dai due processi.
Si supponga ora che avvenga la seguente sequenza di due processi P1 e P2 che eseguono la primitiva ALLOC:
P1
P2
ptr  stack(top);
...
(la CPU è assegnata a P2 e P1 viene sospeso)
ptr  stack(top);
top  top-1;
top  top-1;
(la CPU è assegnata a P1)
Le due ALLOC interfogliate causano due problemi:

P1 e P2 allocano la stessa area di memoria

Un’area di memoria diventa inaccessibile a tutti i processi
Quindi al fine di evitare i problemi mostrati occorre che una risorsa condivisa possa essere usata da UN SOLO PROCESSO ALLA VOLTA.
In altre parole occorre attuare una mutua esclusione, cioè occorre impedire che più di un processo alla volta legga/scriva “contemporaneamente” dati condivisi.
Se un processo sta usando una risorsa condivisa, bisogna impedire ad altri di poterlo fare.
Ma non basta. Occorre che siano soddisfatte 4 condizioni:

due processi non devono mai trovarsi nelle loro sezioni critiche contemporaneamente

non si deve fare alcuna assunzione sulle velocità e sul numero delle CPU

nessun processo in esecuzione fuori dalla sua sezione critica può bloccare altri processi

nessun processo deve aspettare indefinitamente (troppo a lungo) per poter entrare in una sua sezione critica
Per cercare di risolvere queste situazioni critiche si possono attuare una serie di soluzioni.
Soluzioni
72 - Tecno1 rel. 17.03.17
Primitive di Lock/Unlock
Una prima soluzione al problema potrebbe essere quella di associare a una risorsa critica una variabile (S) condivisa che assume due valori: rosso (0) nel caso il
processo è dentro una sezione critica , verde (1) in caso contrario.
Consideriamo le due primitive, LOCK (S) e UNLOCK(S) . Un processo che vuole entrare in una sezione critica :
..
LOCK(S)
Regione critica
UNLOCK(S)
…
le Primitive saranno cosi’ implementate:
LOCK(S)
While (S==0); //se è rosso … non fare niente
S=0; //mettilo rosso!
UNLOCK(S)
S=1; //mettilo verde!
Quando un processo vuole entrare nella sua regione critica, controlla S: se è rossa aspetta, altrimenti la mette a rossa, ed entra nella sezione critica.
problema:
un P1 legge S e prima che ne modifichi il valore, viene tolta la CPU e data ad un altro processo P2. P2 legge S, la trova verde ed entra nella sezione critica. P1
riprende, setta S rossa ed entra nella sezione critica. Viene meno il vincolo 1 !
Occorre quindi fare in modo che le primitive siano INDIVISIBILI: per fare ciò, un metodo, è quello di disabilitare le interruzioni appena si entra in una sezione
critica.
Problema:
E se un processo utente disabilitasse le sue interruzioni, e non le riabilitasse più? E’ la fine!!!
Se le CPU sono più di una, la disabilitazione riguarda una sola CPU, le altre potrebbero eseguire istruzioni che accedono alla memoria condivisa. (vincolo 2)
Sebbene Lock e Unlock, con la disabilitazione delle interruzioni, garantiscano la correttezza, almeno in linea di massima, l’efficienza NON è affatto garantita.
Due sono i problemi che nascono.

Attesa attiva (busy waiting) : quando un processo esegue una Lock continua a testare il valore di S finchè diventa verde; in tal modo essa occupa
continuamente e inutilmente la CPU!

Rinvio Infinito non esiste alcun ordine con cui vengono eseguiti i processi che eseguono una Lock. Cosi’ un processo potrebbe aspettare molto tempo
prima di accedere a una sezione critica e, al limite, non entrarvi mai perché sempre anticipato da un altro processo che diventa attivo sempre prima di
lui.
I problemi esposti derivano dal fatto che, mediante Lock e Unlock, è il singolo processo che provvede a sincronizzarsi con gli altri.
Tutto cio’ ci fa pensare che il controllo dei processi e delle sezioni critiche vada delegato a chi ha una visione complessiva dello stato del sistema : il NUCLEO!
Ecco perché Lock e Unlock vengono sostituite da due nuove primitive chiamate P e V che agiscono su un semaforo.
Semafori
Da quanto detto emerge come processi logicamente corretti possono produrre errori se non correttamente sincronizzati. Inoltre, cio’ che è piu’ grave, compaiono
errori dipendenti dal tempo cioè dalla velocità relativa di esecuzione dei processi: come nell’esempio del Produttore-Consumatore: provate a trovare la sequenza
corretta e quelle errate.
E’ quindi INDISPENSABILE ricorrere a MECCANISMI ESPLICITI DI SINCRONIZZAZIONE. IL meccanismo base , messo a disposizione dal nucleo, è il SEMAFORO
(Dijkstra , 1965) che , nella versione base consiste in un intero non negativo che, a parte l’ inizializzazione, puo’ essere usato solo da due primitive : P per Wait
(dall’olandese Proberen: provare) e V per Signal (dall’olandese verhogen: incrementare)
73 - Tecno1 rel. 17.03.17
SEMAFORO BINARIO
Il semaforo Binario è una VARIABILE BINARIA (S) sulla quale possono essere eseguite due primitive indivisibili P e V cosi’ definite:
(nota 0=rosso . 1=verde):
P(S) o Wait(S)
while S==0 ; //se è rosso non fare niente
S=0;
//mettilo rosso!
V(S) o Signal(S)
S=1; //mettilo verde
Come Lock e Unlock sono indivisibili ma essendo implementate dal nucleo del S.O, esse consentono di evitare sia l’attesa attiva che il rinvio infinito.
Un semaforo può essere modificato da parte del codice utente solamente con tre chiamate di sistema:
1. init (s, 1) //per inizializzare il semaforo s a 1
2. wait (s) // richiesta risorsa
3. signal(s)// rilascio
Intuitivamente, il significato delle operazioni per un semaforo binario, è il seguente:
con l'inizializzazione, cioè l’assegnazione del valore 1 al semaforo, si dichiara la disponibilità della risorsa
Con l'operazione P, un task chiede di riservare un'unità della risorsa. Se la risorsa non è disponibile, il task viene messo in attesa, per essere risvegliato solo
quando gli sarà assegnata l'unità richiesta.
Con l'operazione V, un task rilascia l'unità di cui non ha più bisogno, e per la quale altri task potrebbero già essere in attesa.
Mutua esclusione
Un utilizzo molto semplice dei semafori si ha per garantire la mutua esclusione nell'accesso a una risorsa semplice: in tal caso basta usare un semaforo binario. Si
chiama la P prima di iniziare a usare la risorsa, e si chiama la V dopo averla usata:
Consideriamo due processi (p1 P2) che devono agire sulla stessa risorsa critica:
Inizializzazione: mutex=1 (verde)
P1
..
P(mutex)
Regione critica che
opera sulla risorsa
V(mutex)
..
P2
..
P(mutex)
Regione critica che
opera sulla risorsa
V(mutex)
..
Produttore / consumatore :
74 - Tecno1 rel. 17.03.17
consideriamo due processi (P1 P2) in cui P1 produce un messaggio e P2 lo utilizza, nell’ipotesi che i messaggi vengano scritti su un buffer a cui possono accedere
entrambi (nello stesso modo in cui un insegnante scrive su una lavagna e lo studente legge dalla lavagna).
Ci serviremo di due semafori : “Vuoto” e “Pieno”
Inizializzazione: vuoto=1(verde) : pieno=0 (rosso)
P1
..
ripeti
produci messaggio
P(vuoto)
Scrivi messaggio nel buffer
V(pieno)
Continua
....
P2
..
ripeti
P(pieno)
leggi messaggio dal buffer
V(vuoto)
Consuma messaggio
continua
..
75 - Tecno1 rel. 17.03.17
SEMAFORO GENERALIZZATO
Un semaforo S è una variabile intera (quindi che assume valori 0,1,2,…n) alla quale si può accedere solo attraverso le seguenti operazioni atomiche: P e V
P(S)
V(S)
while S <= 0; //non fare niente
S=S+1; //incrementa il valore
S= S-1; //decrementa il valore
Le modifiche al valore intero del semaforo in P e V sono eseguite atomicamente: mentre un processo modifica il valore di un semaforo, nessun altro processo può
simultaneamente modificare il valore di questo stesso semaforo. Se due processi tentano di eseguire “contemporaneamente” P(S) e V(S), queste operazioni
saranno eseguite sequenzialmente in un ordine arbitrario.
Intuitivamente, il significato delle operazioni per un semaforo generalizzato è il seguente:

con l'inizializzazione, cioè l’assegnazione di un valore intero al semaforo, si dichiarano quante unità di un tipo di risorsa sono disponibili.

Con l'operazione P, un task chiede di riservare un'unità della risorsa. Se non sono disponibili unità, il task viene messo in attesa, per essere risvegliato
solo quando gli sarà assegnata l'unità richiesta.

Con l'operazione V, un task rilascia l'unità di cui non ha più bisogno, e per la quale altri task potrebbero già essere in attesa.
Produttore / consumatore con buffer multiplo
Consideriamo due processi (p1 P2) in cui P1 produce messaggi e P2 li utilizza, nell’ipotesi che i messaggi vengano scritti su un buffer a cui possono accedere
entrambi. Ci serviremo di due semafori : “Vuoto” e “Pieno”
Inizializzazione: vuoto=n(verde, verde, verde ,..) : pieno=0 (rosso)
P1
..
ripeti
produci messaggio
j=j+1 | mod n
P(vuoto)
Scrivi messaggio nel buffer j-esimo
V(pieno)
Continua
....
P2
..
ripeti
k= k+1 |mod n
P(pieno)
leggi messaggio dal k-esimo buffer
V(vuoto)
Consuma messaggio
continua
..
Note sull’implementazione di P e V
P(s) //wait(s), viene chiamata tramite SVC da un processo in EXEC che fa una P(s))
If (s>0 ) //verde
S = s-1
Else //rosso
<Salvataggio contesto di P (PCB <- Cima dello Stack (PC))>
<Accodamento di P nella coda del semaforo S (in Attesa), cioè cambia lo stato da running a waiting>>
<Selezione di P’ (dalla coda dei processi pronti)>
<Ripristino contesto di P’ (Cima dello Stack (PC)<- PCB)>
<P’ in exec >
V(s) ( Signal(s), viene chiamata da SVC o interruzione asincrona)
If (coda sul sem. s vuota)
S = s+1
Else
<Estrazione di P’ dalla coda di s >
<Inserimento di P’ nella coda dei processi pronti >
<Selezione eventuale, di P’da mettere in exec, cioè cambio di stato da waiting a
ready >
--------------------------------------------76 - Tecno1 rel. 17.03.17
Nota:
- si ricorda che un semaforo viene implementato per mezzo di una variabile e un puntatore alla coda dei processi sospesi su quel semaforo (che cioè
hanno eseguito una P trovando il semaforo rosso)
- Se uno o più processi sono in attesa su S, consenti a uno dei processi in wait su S di proseguire.
- Il numero contenuto nel semaforo rappresenta il numero di risorse di un certo tipo disponibili ai task.
- Un caso particolare molto usato è il semaforo binario, in cui gli unici valori possibili sono 0 e 1.
- Le primitive wait e signal vengono eseguite dal nucleo del S.O. e devono essere indivisibili.
Problemi:
1. Drink dei filosofi
I filosofi possono compiere 2 attività non contemporaneamente: bevono e pensano.
Immaginiamo 2 filosofi seduti in torno a un tavolo che dispongono di un unico bicchiere e possono farsi uno dei drink sottostanti:
“ Bloody Mary di Zio Paolo” è un analcolico a base di di limone, acqua tonica e
- “Zombie o Punch del bucaniere Paolo” è un a base succo di mela, menta piperita e spremuta d’arancia
- “Long Island Iced Tea di Zio Paolo” è un a base di verde, succo di ananas e cannella
2 Pranzo dei filosofi (dining philosophers)
Platone
Socrate
Cartesio
Pascal
Kierkegaard
E’ un esempio che illustra un comune problema di .
Si tratta di un classico problema di fra paralleli. L'esempio fu descritto nel da .
Cinque filosofi siedono ad una tavola rotonda con un piatto di spaghetti davanti:
Sul tavolo ci sono 5 bacchette (o forchette) : ogni filosofo per mangiare deve avere 2 bacchette in mano: risorse: bacchette b0...b4. I 5 filosofi possono compiere
2 attività non contemporaneamente: pensare e mangiare.
•
I filosofi mangiano e pensano
•
Quando un filosofo ha fame, tenta di prendere le due bacchette che ha accanto (può prendere solo quelle immediatamente alla propria
destra e sinistra)
77 - Tecno1 rel. 17.03.17
•
Prende prima una bacchetta poi l’altra
•
Non rilascia le bacchette finché non ha finito (non può prendere una bacchetta se è in mano ad un altro filosofo)
Soluzione 1
processi: Filosofo()
S1,2,3,4,5=1 (verde)
process Filosofo {
while (true) {
}
P(Si);
P(Si+1); |mod5;
mangia;
V(Si);
V(Si+1); |mod5;
}
Ma va bene? No, Problema la morte d'inedia (): la soluzione NON esclude il deadlock, ad esempio se tutti i filosofi hanno fame contemporaneamente e
prendono prima la bacchetta alla loro destra.
Alcune soluzioni:

Solo quattro filosofi possono essere seduti contemporaneamente a tavola

Un filosofo può prendere le sue bacchette solo se sono entrambe disponibili (attenzione alle sezioni critiche)

Adottare una soluzione asimmetrica. Un filosofo dispari prende prima la bacchetta di sinistra, un filosofo pari prende prima la bacchetta di destra.
Soluzione 2
Semaforo Room=4
while (true) {
P(Room);
P(Si);
P(Si+1); |mod5;
mangia;
V(Si);
V(Si+1); |mod5;
V(Room);
}
}
Un torrente e attraversato da un ponte.
Caso 1. Un piccolo fiume è attraversato da un ponte. Il ponte è lungo quanto una macchine, ma è largo come una macchina, per cui la circolazione avviene a
senso unico alternato. Sul ponte passa una sola macchina alla volta. (difficoltà bassa)
Caso 2. Un piccolo fiume è attraversato da un ponte. Il ponte è lungo quanto tre macchine, ma è largo come una macchina, per cui la circolazione avviene a
senso unico alternato. (difficoltà alta)
Le regole di circolazione sono:
1. indipendentemente dalla riva da cui provengono, le macchine impegnano il ponte nell’ordine di arrivo;
78 - Tecno1 rel. 17.03.17
2. una macchina non puo impegnare il ponte finchè questo è occupato da una o più macchine provenienti dalla riva opposta;
3. una macchina non puo impegnare il ponte se questo è già occupato da tre macchine.
Scrivere in pseudocodice i programmi corrispondenti a macchine provenienti dalla riva destra e dalla riva sinistra, utilizzando i
semafori per la sincronizzazione.
Soluzione
Innanzitutto la capacità del ponte (requisito (3)) è gestibile con un solo semaforo, opportunamente inizializzato, che protegge la sola fase di transito. In secondo
luogo, il requisito (1) richiede laprotezione (con mutua esclusione tramite semafori) del protocollo di accesso al ponte, in modo da forzare l’ordinamento di tutte
le macchine indipendentemente dalla riva di provenienza.
int m=0;
sem mutexdx=1; /* per controllo di flusso e mutex */
sem mutexsx=1; /* per controllo di flusso e mutex */
sem portata=3; /* capacita’ del ponte */
sem accesso=1; /* forza l’ordinamento delle macchine che arrivano */
Macchina_Destra() {
wait(accesso);
wait(mutexdx); /* per evitare scontri e per mutex */
m++;
if (m==1) wait(mutexsx); /* prima macchina a dx, blocca macchine
dall’altra riva sx*/
signal(mutexdx);
signal(accesso);
wait(portata);
attraversa_ponte();
signal(portata);
wait(mutexdx);
m--;
if (m==0) signal(mutexsx); /*ultima macchina a dx, sblocca macchine
dall’altra riva sx */
signal(mutexdx);
}
Macchina_Sinistra(){
wait(accesso);
wait(mutexsx);
m++;
if (m==1) wait(mutexdx);
signal(mutexsx);
signal(accesso);
wait(portata);
attraversa_ponte();
signal(portata);
wait(mutexsx);
m--;
if (m==0) signal(mutexdx);
signal(mutexsx);
}
Un incrocio di due grandi viali (uno in direzione Nord-Sud, l’altro in direzione Est-Ovest) è regolato da un vigile.
Sincronizzazione completa: avvio il thread2 quando il thread1 ha finito di fare quel che deve fare (semafori incrociati S inizializzato a 0 e P a 1)
Soluzione:
Thread
loop{
wait(S)
<regione
signal(p)
}
Thread
loop{
wait(p)
<regione
signal(s)
}
1
critica>
2
critica>
Il conto corrente
Un conto bancario è condiviso tra più persone. „ Ciascuna può depositare o prelevare mazzette da 100 euro dal conto, ma il saldo non deve mai diventare
negativo. „ Se una persona vuole prelevare e ci sono soldi a sufficienza, lo fa aggiornando il saldo, altrimenti resta in attesa che il saldo renda possibile il prelievo
e, non appena c’è stato un deposito cerca di effettuare il prelievo. „ Quando una persona deposita, avverte un’altra eventuale persona in attesa che c’è stato un
deposito.
79 - Tecno1 rel. 17.03.17
Il barbiere addormentato
• Un negozio di barbiere ha un barbiere, una poltrona da barbiere e N sedie per i clienti in attesa
• Se non ci sono clienti, il barbiere si mette sulla sedia da barbiere e si addormenta
• Quando arriva un cliente, sveglia il barbiere addormentato e si fa tagliare i capelli sulla sedia da barbiere
• Se arriva un cliente mentre il barbiere sta tagliando i capelli a un altro cliente, il cliente si mette in attesa su una delle sedie
• Se tutte le sedie sono occupate, il cliente se ne va!
Soluzione
Possiamo vedere questo problema come un problema di produttore-consumatore:

I produttori sono i clienti, che “producono” se stessi.

Il consumatore è il barbiere, che consuma un cliente alla volta.
Innanzitutto, dobbiamo descrivere la “vita” del barbiere e dei clienti:
process Barbiere {
while (true) {
attendi cliente
// taglia capelli
libera poltrona }
}
process Cliente {
verifica se c'è posto, altrimenti esci
attendi turno
// fatti tagliare i capelli
}
E questo è il programma:
Semafori: Cliente: Rosso, Poltrona: Rosso, Sedia: Verde
process Barbiere {
SedieLibere =N;
while (true) {
P(Cliente);
process Cliente {
// taglia capelli
P(Sedia);
V(Poltrona);
if (sedieLibere==0){//non ci sono sedie libere
}
V(Sedia);
}
return; //se ne va
}
sedieLibere--;
V(Sedia);
V(Cliente);
P(Poltrona);
P(Sedia);
sedieLibere++;
V(Sedia);
// Fatti tagliare i capelli e poi esci
}
Alcuni errori visti nelle soluzioni degli studenti:
while(sedieLibere==0) // Inserito all'inizio del codice cliente ; //non fa niente
Questo è busy waiting e non rispetta le richieste del problema (se ne va indignato). Qui inrealtà attende, ma senza mettersi in coda sul semaforo.
Utilizzo di un semaforo “sedie” inizializzato a N. Bisogna essere molti cauti nell'utilizzare unasoluzione del genere: se il cliente si sospende su “sedie”, i primi N
clienti passano (senza in realtà aspettare), mentre i clienti in eccesso attendono (mentre dovrebbero andarsene).
Deadlock
In un ambiente multiprogrammato più processi possono competere per un numero finito di risorse. Un processo richiede risorse e se queste non sono disponibili
in quel momento, il P entra in uno stato di waiting.
80 - Tecno1 rel. 17.03.17
Può accadere che un P in waiting non modifichi mai lo stato perché le risorse per cui è in attesa sono state assegnate ad un altro P in attesa.
Nota: Es. di due processi in Blocco Critico (deadlock)
s1=1, s2=1
Processo 1
Processo 2
..
..
P(s1)
P(s2)
Utilizza Risorsa (R1)
Utilizza Risorsa (R12)
..
..
P(s2)
P(s1)
Utilizza Risorsa (R2)
Utilizza Risorsa (R1)
..
..
V(s1)
V(s2)
V(s2)
V(s1)
Rilascio R1, R2
Rilascio R1, R2
N.B. sse la sequenza è: P1,P2,P1,P2 si ha il Blocco: P1 è bloccato su P2 e viceversa.
Ad ex. due processi (A e B) devono leggere da un nastro e stampare. A ottiene l’uso della stampante, B del nastro. Quindi A chiede l’uso del
nastro e aspetta, B chiede l’uso della stampante e aspetta: BLOCCATI!
Esempio :
Supponiamo di dover attraversare un fiume su una fila di sassi che affiorano. Possiamo paragonare la persona che deve attraversare e quindi richiede le pietre,
ad un processo che richiede risorse.
Il deadlock si verifica quando due persone iniziano l’attraversamento da parti opposte e si incontrano in mezzo.
Il passaggio su una pietra può essere visto come la richiesta di una risorsa, mentre la rimozione del piede come il rilascio della risorsa. Il deadlock si verifica
quando le due persone tentano di passare sullo stesso sasso.
Può essere risolto solo se una persona si ritrae dalla parte del fiume da cui è partita.
In termini del SO operativo questo “ritirarsi” è detto ROLLBACK
Occorre notare che se più persone devono attraversare partendo dalla stessa parte, allora più di una persona deve tornare indietro per risolvere il deadlock.
Il solo modo per assicurare che non si verifichi il dedlock è quello di richiedere ad ogni persona di attraversare il fiume, seguendo un protocollo concordato.
Per esempio si potrebbe richiedere che chi ha intenzione di attraversare, si informi che nessun altro stia già attraversando in senso opposto. In questo caso
occorre attendere che l’altro termini l’attraversamento. Per risolvere il problema occorre un meccanismo per determinare se qualcuno sta attraversando il fiume.
Questo è possibile se in ogni momento può essere rilevato lo stato di tutte le pietre.
Supponiamo che due persone vogliano attraversare partendo da lati opposti nello stesso istante. Se entrambi partono, si verificherà il deadlock. Se entrambi
attendono che l’altro inizi, si verificherà un’altra forma di deadlock.. Una soluzione potrebbe essere quella di assegnare una priorità a ciascuna riva del fiume.
Si osservi come sia possibile che uno o più processi possano attendere indefinitamente: STARVATION. (se una sequenza continua di persone deve attraversare
sempre dalla parte ad alta priorità). Occorre quindi definire un algoritmo che ogni tanto alterni la direzione.
In sintesi si può verificare una situazione di stallo se:
MUTUA ESCLUSIONE: ogni risorsa è assegnata ad un solo P oppure è
–
solo una persona può passare su un sasso in un certo istante
disponibile. Questa può essere imposta solo a risorse non condivisibili.
–
ogni persona passa su un sasso e attende di passare sull’altro.
HOLD AND WAIT: un P può aver richiesto e ottenuto una risorsa, ed essere in
–
non si può spostare una persona che è su un sasso
attesa di altre risorse in uso. Occorre assicurare che quando un P richiede r,
–
una persona che parte da un lato è in attesa che l’altra termini e
non ne stia già usando un’altra: imporre a P di fare tutte le richieste prima di
viceversa.
iniziare l’esecuzione. Per es. le system call per le risorse devono precedere
tutte le altre.(può riservare per molto tempo una risorsa che in realtà sarà
usata solo per breve tempo) Oppure Un P può richiedere r solo se non ne ha
di assegnate. Prima di richiedere una risorsa, deve rilasciare tutte quelle in
uso. Un P può richiedere tante risorse (cpu time, memory space, file, I/O
device,…), quante ne occorrono per portare a termine il suo compito. In ogni
caso il numero di risorse richieste non può superare il numero di risorse
disponibili.
NO PREEMPTION: le risorse in uso non possono essere tolte forzatamente ad
un P. Una risorsa può essere rilasciata solo volontariamente dal P che l’ha in
uso quando ha completato il task.
CIRCULAR WAIT: deve esistere un insieme di P in waiting P0,P1,…Pn per cui
P0 è in attesa di una risorsa in uso a P1, P1 di una in uso a P2, ….Pn attende
una risorsa in uso a P0.
Un insieme di P è in uno stato di deadlock quando tutti i P dell’insieme sono in attesa di un evento che può essere causato solo da un P dell’insieme.
SOLUZIONI

Protocollo per assicurare che il sistema non entri in uno stato di deadlock (prevenire)

Permettere che si verifichi, e poi tentare di recuperare.(curare)
Meglio prevenire, curare può essere costoso e difficile.
tecniche anti-stallo
Allocazione Globale delle risorse: “se tutte le risorse sono disponibili assegnale al processo, altrimenti sospendilo” (evita lo stallo , ma poco
efficiente e antimodulare)
81 - Tecno1 rel. 17.03.17
Allocazione gerarchica : “se le risorse sono ordinate in una gerarchia di livelli un processo che possiede una risorsa Rk (livelo k) non puo’ richiederne
un’altra di livello l<=k senza rilasciare prima Rk, richiedere e ottenere Rl, richiedere Rk” ( evita lo stallo ma è pesante!!)
Algoritmo del Banchiere: “quando un processo richiede una o piu’ risorse, gli vengono assegnate solamente se rimane libero un numero sufficiente
di risorse atto a soddisfare la richiesta massima di almeno uno dei processi che hanno già una risorsa associata.” (Cosi’ almeno un processo alla volta
potrà soddisfare la sua richiesta. E’ pesante, è basato sul caso pessimo, puo’ causare un Blocco Individuale di un processo)
Preemption (svuotamento anticipato) : “toglie d’autorità una o piu’ risorse al processo se si verifica un blocco critico” (Non previene lo stallo, ma
prende provvedimenti se si verifica. Difficile: quanto tempo dura uno stallo????)
Primitive di Comunicazione tra Processi
I semafori sono sufficienti a risolvere i problemi di mutua esclusione e sincronizzazione tra processi concorrenti, ma non è semplice programmare con essi: ee
per la mutua esclusione i Semafori sono sufficientemente potenti, per il produttore-consumtore diventano già macchinosi.
Sono quindi stati proposti due meccanismi più agevoli al programmatore, i monitor e lo scambio di messaggi.
Nota
•
•
•
•
•
Processes can communicate through shared areas of memory
–
the Mutual Exclusion problem and Critical Sections
Semaphores - a synchronisation abstraction
Monitors - a higher level abstraction
Inter-Process Message Passing much more useful for information transfer
–
can also be used just for synchronisation
–
can co-exist with shared memory communication
Two basic operations : send(message) and receive(message)
–
message contents can be anything mutually comprehensible
»
data, remote procedure calls, executable code etc.
–
usually contains standard fields
»
destination process ID, sending process ID for any reply
»
message length
»
data type, data etc.
Il secondo, di cui ci occupiamo ora, è adatto ai sistemi distribuiti, dove non si possono quindi usare zone di memoria condivise, ma è comunque utilizzabile
anche su un processore in multiprogrammazione e permette di costruire primitive piu’ potenti a partire dei “mattoni”-semafori, per lo scambio dati tra processi.
INVIA-RICEVI
S1=1, s2=0
Invia(buffer,areadati1)
P(s1)
Copia Areadati1-> Buffer
V(s2)
Ricevi(buffer,areadati2)
P(s2)
Copia Buffer -> Areadati2
V(s1)
N.B. S1,S2 e Buffer sono aree comuni fornite dal S.O. mentre Areadati1,2 sono locali ai processi
N.B. Svantaggi: Il Buffer è di lunghezza fissata (troppo?, poco?) ; doppie operazioni di scrittura/lettura
Comunicazione indiretta
• I processi cooperanti non sono tenuti a conoscersi reciprocamente e si scambiano messaggi depositandoli/prelevandoli da una mailbox
condivisa.
• La mailbox (o porta) è una risorsa astratta condivisibile da più processi che funge da contenitore dei messaggi.
MAIL BOX (SEND-RECEIVE)
MailBox = (Semaforo (s) + puntatore alla coda di messaggi (messaggio= area dati + puntatore al prossimo messaggio in coda) )
S=0
Send(Mail, messaggio)
Inserisci messaggio nella coda di Mail
V(s)
Receive(Mail, messaggio)
P(S)
Estrai il primo messaggio nella coda di Mail
N.B. si possono accodare infiniti messaggi ma si possono limitare. Come?
Osservazione : I semafori, le regioni critiche, i monitor sono stati concepiti basandosi sull’ipotesi che tutti i processi possano comunicare e sincronizzarsi
basandosi su una memoria comune. Se pero’ questo non risulta vero , come in rete, gli strumenti risultano inadeguati. Cio’ che viene richiesto pero’ un modello di
“Scambio Messaggi”: i processi possono comunicare e/o sincronizzarsi SOLO attraverso l’invio e la ricezione di MESSAGGI lungo CANALI DI COMUNICAZIONE (che
costituiscono, in un certo senso, le uniche risorse condivise). I processi, quindi, possono interagire solo attraverso l’ INVIO e la RICEZIONE di MESSAGGI!
82 - Tecno1 rel. 17.03.17
Monitor
( )
Sono stati ideati da C.A.R.Hoare e P.Brinch Hansen (1974-75), e richiedono un linguaggio di programmazione che li preveda (per i semafori, basta avere a
disposizione una libreria di funzioni, chiamabile ad esempio dal C ed integrata con il sistema operativo, che realizzi up e down).
Idea: garantire l’integrità di una struttura dati condivisa permettendo l’accesso soltanto attraverso le procedure del monitor (tipi di dato astratto).
Un monitor è …
un aggregato di sottoprogrammi, variabili e strutture dati
Solo i sottoprogrammi del monitor possono accederne le variabili interne
Solo un processo alla volta può essere attivo entro il monitor
o
Proprietà garantita dai meccanismi del supporto a tempo di esecuzione del linguaggio di programmazione concorrente
Funzionalmente molto simile al kernel del sistema operativo
o
Il codice necessario è inserito dal compilatore direttamente nel programma eseguibile
La garanzia di mutua esclusione da sola può non bastare per consentire sincronizzazione intelligente
Due procedure operanti su variabili speciali (non contatori!) dette condition variables, consentono di modellare condizioni logiche specifiche del problema
Wait(<cond>) // forza l’attesa del chiamante
Signal(<cond>) // risveglia il processo in attesa
Il segnale di risveglio non ha memoria. Va perso se nessuno lo attende
La primitiva Wait permette di bloccare il chiamante qualora le condizioni logiche della risorsa non consentano l’esecuzione del servizio
La primitiva Signal notifica il verificarsi della condizione attesa al (primo) processo bloccato, risvegliandolo
Il processo risvegliato compete con il chiamante della Signal per il possesso della CPU
Wait e Signal sono invocate in mutua esclusione Non si può verificare race condition
Sincronizzazione di thread in Java
Java offre un costrutto simile al monitor tramite classi con metodi synchronized– Ma senza condition variable
Le primitive wait() e notify() invocate all’interno di metodi synchronized evitano il verificarsi di race condition
In realtà il metodo wait() può venire interrotto, e l’interruzione va trattata come eccezione!
I thread in Java
sono oggetti particolari ai quali si richiede un servizio (chiamato start()) corrispondente al lancio di una attività, di un thread, che procede in concorrenza a chi lo
ha richiesto
Java usa un meccanismo che è una forma di monitor: ogni istanza di qualsiasi oggetto ha associato un mutex. Quando un thread esegue un metodo che è stato
83 - Tecno1 rel. 17.03.17
dichiarato sincronizzato mediante l’identificatore synchronized, entra in possesso del mutex associato all’istanza e nessun altro metodo sincronizzato può essere
eseguito su quell’istanza fintanto che il thread non ha terminato l’esecuzione del metodo.
–
New Thread: Creato subito dopo l’istruzione new
–
Runnable: thread è in esecuzione, o in coda per ottenere l’utilizzo
della CPU
–
Not Runnable: il thread entra in questo stato quando è in attesadi
un’operazione di I/O, o dopo l’invocazione dei metodi suspend(),wait(),sleep()
–
Dead: al termine “naturale” della sua esecuzione o dopo l’invocazione
del suo metodo stop()da parte diun altro thread
Metodi per il controllo di thread
•
start() fa partire l’esecuzione di un thread. La macchina virtuale Java invoca il metodo run() del thread appena creato
•
stop() forza la terminazione dell’esecuzione di un thread. Tutte le risorse utilizzate dal thread vengono immediatamente liberate
•
suspend() blocca l'esecuzione di un thread in attesa di una successiva operazione di resume. Non libera le risorse impegnate dal
thread (possibilità di deadlock)
•
resume() riprende l’esecuzione di un thread precedentemente sospeso. (Se il thread riattivato ha una priorità maggiore di quello
correntemente in esecuzione, avrà subito accesso alla CPU, altrimenti andrà in coda d'attesa
•
sleep(long t) blocca per un tempo specificato (time) l'esecuzione di un thread.
•
join() blocca il thread chiamante in attesa della terminazione del thread di cui si invoca il metodo.
•
yield() sospende l'esecuzione del thread invocante, lasciando il controllo della CPU agli altri thread in coda d’attesa
/* Cosa fare:
1. interfaccia runnable (implements Runnable)
2. Implementazione metodo run() (void run())
3. creare un’istanza della classe tramite new (ProvaThread2 pt = new ProvaThread2())
4. creare un’istanza della classe Thread con un’altra new, passando com parametro l’istanza della classe che si è creata (Thread t =new Thread (pt))
5. invocare il metodo start()sul thread creato,producendo la chiamata al suo metodo run()(t.start();
*/
public class ProvaThread2 implements Runnable
{
public static void main (String argv[] ) {
ProvaThread2 pt = new ProvaThread2();
Thread t =new Thread (pt);
t.start();
pt.m2();
}
public void run() {
m1();
}
}
}
synchronized void m1() {
for ( char c= ‘A’ ; c < ‘F’ ; c++) {
System.out.println(c);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {}
}
void m2 () {
for ( char c= ‘1’ ; c < ‘6’ ; c++) {
System.out.println(c);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {}
}
}
Nell’esempio due metodi m1 e m2, vengono invocati da due thread su una stessa istanza pt. Uno dei due metodi è stato dichiarato synchronized mentre l’altro,
m2, no. Dunque il mutex associato a pt viene acquisito dal metodo m1, ma non blocca l’esecuzione di m2 perché esso non tenta di acquisire il mutex. Il risultato
prodotto è il seguente:
1
A
2
B
3
C
4
84 - Tecno1 rel. 17.03.17
D
5
E
Se invece si dichiara synchronized anche il metodo m2, si hanno due thread che tentano di acquisire lo stesso mutex, per cui i due metodi vengono eseguiti in
mutua esclusione prima uno e dopo l’altro:
1
2
3
4
5
A
B
C
D
E
85 - Tecno1 rel. 17.03.17
Gestione della Memoria
Indirizzi di memoria fisici e logici
Normalmente
un
programma
risiede
su
disco
in
formato
binario
eseguibile.
Per essere eseguito deve essere portato in RAM e divenire processo. Durante la sua esecuzione, un processo accede a istruzioni e dati in memoria. Al suo
termine, viene liberata la memoria che occupava.
Il
programma
può
essere
trasferito
in
qualsiasi
punto
della
RAM
prima
di
essere
eseguito.
Generalmente, però, gli indirizzi del programma sorgente sono simbolici (es.: nomi di variabili).
Gli indirizzamenti logici e fisici permettono di separare la parte software dalla parte hardware:

Indirizzo logico (o virtuale/software): usato dal programma

Indirizzo fisico (hardware): usato dall’unità di memoria
Traduzione di indirizzi logici in fisici
Il collegamento tra indirizzi logici e fisici puo’ avvenire in tre fasi diverse:

Compile time : la locazione di memoria che verrà usata è nota a priori (codice assoluto)

Load time: Il programma deve essere scritto con codice rilocabile

Execution time : Quando una istruzione viene eseguita viene fatta la sua traduzione
Nel primo caso, ci vuole un compilatore che associa (bind) questi indirizzi simbolici a indirizzi rilocabili (es.: “14 byte dall’inizio di questo modulo”). Il linker (o il
caricatore/loader) fa corrispondere questi indirizzi rilocabili a indirizzi assoluti.
Un indirizzo generato dalla CPU è indicato solitamente come logico, mentre un indirizzo visto dalla memoria è fisico (questo indirizzo viene caricato nel MAR
memory address register):
Memory-Management Unit (MMU)
Device hardware di supporto alla traduzione di indirizzi virtuali in indirizzi fisici
Si pone tra CPU e memoria. Fa si che, ad ogni indirizzo generato dalla CPU, prima di inoltrare la richiesta alla memoria, sia aggiunto al momento
dell’esecuzione e senza cambiare il codice il valore contenuto in un registro
86 - Tecno1 rel. 17.03.17
VLSI VI475 MMU "Apple HMMU" -
Swapping
Problema: Abbiamo una memoria finita e vogliamo eseguire molti processi. Posso tenere in memoria solo il processo che sto effettivamente eseguendo
Soluzione: Un processo può essere temporaneamente spostato (swapped) dalla memoria centrale alla memoria di massa (backing store) e successivamente
riportato in memoria per continuarne l’esecuzione
87 - Tecno1 rel. 17.03.17
Allocazione della memoria
Rimane il problema di studiare con quali strategie associare una zona di memoria ad un processo. In generale dividiamo la memoria in zone all’interno delle quali
andremo a caricare il codice binario di un programma
In generale distinguiamo due casi:

Allocazione contigua

Allocazione non contigua
Allocazione contigua
La memoria centrale è, di norma , divisa in almeno due partizioni: una per il Sistema Operativo, l’atra per i processi utente.
Se vogliamo che piu’ processi utente risiedano in Memoria Centrale dobbiamo allocarli in memoria usando una sequenza di locazioni senza interruzioni.
Dividiamo la memoria in partizioni e diamo ad ogni processo una sua partizione.
Prima di tutto occorre però tener presente che la memoria che contiene il S. O. va protetta dai processi utente. A questo proposito, esiste un registro limite che
contiene l’indirizzo che un processo utente NON puo’ superare,
Partizioni fisse
Dividiamo la parte di memoria per i processi utente in partizioni di dimensione fissa



Poco flessibile
Pone dei limiti alla dimensione di un programma
Grandi sprechi di memoria (frammentazione interna) causati dai processi piccoli
Partizioni variabili
Allochiamo delle partizioni di dimensione variabile per alloggiare i processi

Buco (Hole) – blocco di memoria disponibile; buchi di diverse dimensioni sono distribuiti nella memoria
o
Quando un processo viene creato, gli si assegnata una zona di memoria prendendola da un buco sufficientemente grande
o
Il S.O. deve mantenere informazioni su Partizioni allocate e Buchi
Problema della Frammentazione


Interna
o
Esterna
o
la memoria allocata è maggiore di quella richiesta e quindi internamente alla partizione esiste memoria inutilizzata
Lo spazio di memoria totale per soddisfare la richiesta esiste, ma non è contiguo: si può ridurre compattando periodicamente la
memoria,spostando i contenuti per mettere insieme i buchi. E’ possibile solo se prevista rilocazione dinamica eseguita a run-time
88 - Tecno1 rel. 17.03.17
Come soddisfare una richiesta di memoria di dimensione n avendo a disposizione una lista di partizioni libere e cercando di ridurre al minimo frammentazione
esterna? Dobbiamo decidere in quale buco infilare (fit) la nuova richiesta (Allocazione dinamica delle partizioni):



First-fit
o
o
o
Best-fit
o
o
o
Worst-fit
o
o
Usiamo il primo buco sufficientemente grande
Non devo guardare l’intera lista
Non è ottimale
Usiamo il buco più piccolo che è sufficientemente grande
Lascio liberi i buchi più grandi per soddisfare future richieste
Performances ridotte
Usiamo sempre il buco piu grande
Non si creano buchi piccolissimi
Allocazione non contigua
Accettiamo che lo spazio utilizzato per allocare un processo possa essere sparpagliato all’interno della memoria.
Dividiamo la memoria in pagine ed assegniamo ad ogni processo un insieme di pagine
Paginazione
La memoria può non essere assegnata tutta in una volta ma man mano che diventa necessario e si rende disponibile:

La memoria viene divisa in blocchi di dimensione fissata chiamati frame (o pagine fisiche)

La memoria logica viene anche lei divisa in blocchi della stessa dimensione chiamati pagine (pagine virtuali)

Il sistema deve tenere traccia di tutti i frame liberi

Serve una tabella delle pagine (page table) per tradurre indirizzi logici in indirizzi fisici

Si può creare frammentazione interna ma non esterna

Schema di traduzione degli indirizzi. Gli indirizzi vengono scomposti in due parti:
o
Numero di pagina - E’ il numero di pagina virtuale (p - page) e viene usato come indice all’interno della page table che contiene il numero
di pagina fisica relativo (f – frame)
o
Scostamento o offset (d) - Indica la posizione della locazione di memoria all’interno della pagina
89 - Tecno1 rel. 17.03.17
segmentazione
L’idea di base consiste nel vedere il programma come una serie di segmenti, ciascuno disgiunto, che rappresentano, ad ex, codice, stack, dati etc. (cfr famiglia
80x86).
La tabella dei segmenti contiene la coppia: base segmento, limite segmento. La base del segmento contiene l’indirizzo fisico iniziale della memoria dove parte il
segmento. Il limite del segmento contiene la lunghezza del segmento. Un indirizzo logico è formato da due parti: numero di segmento (s) e scostamento nel
segmento (offset)
Memoria Virtuale
Abbiamo visto alcune tecniche per gestire la memoria centrale. Esse permettono la presenza contemporanea di più processi in memoria, ma un programma
potrebbe risiedere in memoria solo parzialmente. La memoria virtuale è una tecnica che permette di eseguire processi che possono anche non essere
completamente contenuti in RAM con una separazione netta della memoria logica da quella fisica:

Lo spazio di indirizzamento logico può essere molto più grande della memoria fisicamente disponibile

Alcune pagine potrebbero essere condivise tra più processi, ad es. il codice binario di un editor che tutti usano
La memoria virtuale viene generalmente gestita a pagine ed implementata con dei meccanismi di Paginazione su richiesta (Demand Paging)
90 - Tecno1 rel. 17.03.17
Paginazione su richiesta (Demand Paging)
Porto una pagina in memoria solo quando è necessario. Quando ho un riferimento ad una locazione di memoria, allora la pagina che la contiene diventa
necessaria:

Diminuiscono le operazioni di I/O

Diminuisce la richiesta di memoria

Diminuiscono i tempi di attesa

Aumenta il livello di multiprogrammazione
Bit di validità
All’interno della tabella delle pagine di ogni processo è associato ad ogni pagina un bit di validità: 1 in-memoria, 0 sul disco.
Inizialmente il valore è 0 per tutte le pagine. Durante la traduzione dell’indirizzo da virtuale a fisico, se il bit di validità è 0, genero un page fault (eccezione di
pagina mancante)
Page Fault
La prima volta che una pagina è necessaria viene generato un Page Fault. Il sistema operativo cerca di capire se:

È un riferimento illegale

Bisogna recuperare la pagina
91 - Tecno1 rel. 17.03.17
Viene allocato un frame (pagina fisica) vuoto, la pagina viene trasferita dal disco al frame appena reso disponibile. Il bit di validità per quella pagina viene posto a
1. L’esecuzione riprende dove era stata interrotta
E se non ci sono frame liberi ? Sostituzione di una pagina: si determina una pagina di memoria non attualmente utilizzata e la si sposta sul disco.
Serve un algoritmo. L’algoritmo deve essere tale per cui venga minimizzato il numero di Page Fault futuri. La stessa pagina potrebbe essere richiamata in memoria
più di una volta. Di solito viene implementato nella routine di gestione del Page Fault per evitare affollamento in memoria. Si fa uso di un bit (dirty bit) per
marcare le pagine modificate, in maniera tale da scrivere solo quelle sul disco
Algoritmo di base


Si individua la locazione sul disco della pagina richiesta


Si legge la pagina nel frame libero (o liberato) aggiornando le tabelle di sistema
Si individua un frame libero
o Se esiste lo si usa
o Se non esiste si usa un algoritmo di sostituzione delle pagine per selezionare un frame vittima e lo si trasferisce sul disco (liberando un
posto)
Viene fatto ripartire il processo
Algoritmi per la sostituzione di pagine
Cercano di minimizzare il numero di Page Fault
● Vengono valutati utilizzando una sequenza di riferimenti a pagine di memoria (stringa di riferimento) e contando il numero di Page Fault generati dal sistema
Stringhe di riferimento
Si tratta di sequenze di riferimenti a pagine. Una stringa di riferimento è una sequenza di eventi, non un diagramma temporale, ad ex:
“1 2 3” potrebbe significare
92 - Tecno1 rel. 17.03.17
1 accesso alla pagina 1, 2000 accessi alla pagina 2, 2 accessi alla pagina 3
Page Fault in funzione del numero di frame in memoria
Algoritmo First-In-First-Out (FIFO)
Teniamo traccia dell’ordine in cui le pagina vengono allocate in memoria. La pagina vittima sarà quella in memoria da più tempo
Gestione Memoria in Windows
Usa la paginazione su richiesta per gruppi di pagine (demand paging with clustering), richiamando quindi non solo la pagina richiesta ma anche quelle a essa
adiacenti.
Alla sua creazione, un processo riceve i valori del minimo insieme di lavoro e del massimo insieme di lavoro. Il minimo insieme di lavoro (working set minimum)
è il minimo numero di pagine caricate nella memoria di un processo che il sistema garantisce di assegnare.
Se la memoria è sufficiente, il sistema potrebbe assegnare un numero di pagine pari al suo massimo insieme di lavoro (working set maximum).
Viene mantenuta una lista delle pagine fisiche libere, con associato un valore soglia che indica se è disponibile una quantità sufficiente di memoria libera
Se si ha un fault, e il processo è al suo massimo, si procede per sostituzione locale
Nel caso in cui la quantità di memoria libera scenda sotto la soglia, il gestore della memoria virtuale usa un metodo noto come regolazione automatica
dell’insieme di lavoro (automatic working set trimming) per riportare il valore sopra la soglia. In pratica, se a un processo sono state assegnate più pagine del suo
minimo insieme di lavoro, il gestore della memoria virtuale rimuove pagine fino a raggiungere quel valore.
93 - Tecno1 rel. 17.03.17
File System
Il concetto di file
(basato su: Sistemi Operativi e Distribuiti - Bellettini – Maggiorini - Università di Milano – D.I.Co.)
“Un file ("archivio") è un insieme di informazioni codificate organizzate come una sequenza (di ), immagazzinate come un singolo elemento su una , all'interno del
esistente su quella particolare memoria di massa.” (Wikipedia)
Un file è quindi uno spazio logico continuo per la memorizzazione dei dati.
Se dal punto di vista dell'utente un file è solitamente un singolo elemento, può succedere che, invece, fisicamente sia scritto su più zone diverse del supporto che
lo ospita: questo fenomeno è molto comune se il supporto di memorizzazione è un disco, mentre è molto raro su nastri magnetici. Uno dei compiti del è rendere
trasparente alle applicazioni la reale suddivisione fisica del file e occuparsi di gestire la scrittura e il recupero delle informazioni dai vari blocchi fisici.
Un file può memorizzare vari tipi di dati:

Codice eseguibile

Dati generici

numeri

caratteri

dati binari

…
I file sono risorse di memoria utilizzabili dai processi ma separate dai propri spazi di indirizzi. I processi possono usarli in toto o in parte, spostando le informazioni
nelle proprie aree di indirizzi.
Si potrebbe pensare che la gestione dei file possa essere fatta direttamente dai processi, ma cio’ comporterebbe una serie di problemi dovuti alla loro
condivisione e protezione. Percio’ è il S.O. che si interessa della loro gestione
File system
Il File System è quella parte del S.O. che si occupa della gestione delle informazioni e fornisce la struttura delle cartelle che conserveranno il sistema
operativo, le applicazioni, i file di configurazione e i dati dell'utente.
Il File system:

identifica e cataloga i file

gestisce le operazioni sui file cioè fornisce primitive e utility per assegnare l’uso dei file ai processi che ne fanno richiesta

alloca su disco lo spazio per la creazione dei file
In pratica il File System fa corrispondere a un modello logico dei file una struttura fisica sul supporto di memorizzazione, e stabilisce i metodi di memorizzazione e
accesso.
Il File system è usato in due accezioni:

File System Logico (visione dell’UTENTE): Come organizzo i file all’interno del mio disco ?

File System Fisico (visione del DISPOSITIVO di archiviazione): Come scrivo fisicamente i dati sul disco ?
Il File System Logico
Definisce le modalità di identificazione dei file, l’organizzazione e le operazioni possibili (creazione, cancellazione, modifica). I file sono risorse che il processo
chiede e rilascia con le operazioni di : apertura e chiusura.
I file posseggono varie strutture, definite dal sistema operativo e dal programma utente:

Nessuna struttura

sequenze di byte o numeri
94 - Tecno1 rel. 17.03.17










Strutturato semplice
Linee
Record a lunghezza fissa
Record a lunghezza variabile
Strutturato complesso
Documento formattato
XML
Doc
File caricabile rilocabile
…
I descrittori dei file aperti sono posti in una tabella apposita. I file sono identificati dalla posizione nella tabella. Ad ogni apertura viene assegnata al processo
l’indice della posizione del file nella tabella dei file aperti del processo (in Linux si chiama File Descriptor). Per ogni file aperto viene assegnato al processo un
puntatore che definisce la posizione corrente all’interno del file, cioè la posizione nel file per cui hanno valore le operazioni (lettura, scrittura..).
Gli attributi di un file servono ad indentificarlo all’interno del file system:

Nome

Tipo

Posizione all’interno della periferica che lo contiene

Dimensione

Data/ora di creazione

Proprietario

Diritti di accesso
Operazioni sui file (dipende dal tipo di organizzazione):

Creazione

Scrittura

Lettura

Posizionamento

seek

Cancellazione

Riduzione della dimensione

truncate
Modalità di accesso:
Accesso sequenziale
12. read next
13. write next
14. reset
Accesso diretto
4. read n
5. write n
Oppure
6. position to n
7. read next
8. write next
Organizzazione del file system per l’efficienza nel trovare un file velocemente
Nomi
o
Utenti diversi potrebbero chiamare con nomi uguali file distinti
o
Lo stesso file potrebbe essere raggiungibile con nomi diversi
Raggruppamenti logici
o
Per proprietà
o
Per tipologia
o
Per contenuto
Strutturazione a directory
Tutti i file su disco sono descritti nella directory: un insieme di strutture incaricate di mantenere informazioni riguardo i file presenti su disco.
La directory è essa stessa un file che contiene un record per ogni file, compresa la directory stessa.
Il record può essere il descrittore del file o il puntatore a una tabella separata.
Immaginando il file system come un armadietto di file, le directory di alto livello possono essere rappresentate come i cassetti, mentre le subdirectory possono
essere rappresentate come schede di file dentro i cassetti.
Queste strutture risiederanno sul disco insieme ai dati, tuttavia dobbiamo decidere



Cosa memorizzare
Come organizzarle
Dove metterle sul disco
Directory ad albero gerarchico: esistono più file directory e ogni descrittore può contenere il nome di un file o di un’altra directory (sottodirectory) partendo da
una directory principale (root/radice).
95 - Tecno1 rel. 17.03.17
Operazioni su una directory
3. Cercare un file
4. Creare un file
5. Cancellare un file
6. Vedere i file in essa contenuti
7. Rinominare un file
NB la cancellazione elimina dalla directory il descrittore del file , ma le informazioni vere e proprie rimangono su disco (e potrebbero essere recuperate)!
Condivisione di dati
Condividere i file tra utenti è spesso utile. La condivisione può essere ottenuta tramite un sistema di diritti di accesso. Se il sistema è distribuito, allora potremmo
voler estendere la condivisione sulla rete. Network File System (NFS) è un modo abbastanza comune di condivisione di file via rete per macchine Unix.
Diritti di accesso
Il proprietario di un file dovrebbe essere in grado di stabilire

quali operazioni possono essere fatte

da chi

Tipi di accessi
o
Read
o
Write
o
Execute
o
Append
o
Delete
o
List
Ad esempio, Access Lists e gruppi (UNIX)
Ogni file appartiene ad un utente ed ad un gruppo. Distinguo tre tipi di utenti:

Il proprietario

quelli facenti parte dello stesso gruppo del file

tutti gli altri
Per ognuno decido delle modalità di accesso

Read

Write

Execute
Ad esempio, Access Lists e gruppi (UNIX)
# > chmod 761 file
owner access
group access
public access
7
6
1
111
110
001
RWX
File system fisico
● MBR master boot record: il settore 0 del disco; contiene il programma che viene caricato dal BIOS all’avvio
● Partition Table (su disco): contiene il punto di inizio e di fine di ogni partizione del disco
Partizioni
96 - Tecno1 rel. 17.03.17
● Boot (control) block: contiene le informazioni necessarie per l’avviamento del SO da quella partizione (se presente)
● Partition Control Block (o Super Block): contiene le informazioni sulla partizioni quali numero e dimensione di blocchi, blocchi liberi, i-node
● i-node (descrittore di file): uno per file…
Metodi di assegnazione dello spazio su disco
(immagini tratta da Sistemi Operativi – Addison-wesley)
FAT File Allocation Table
Ogni disco ne ha una, e se il disco è utilizzato viene anche ricopiata in memoria centrale.
Per ogni file la directory contiene l'indirizzo del primo blocco del file, ogni blocco del disco ha una entry nella FAT, che in generale contiene l'indirizzo del blocco
successivo.
Esempio:
La directory corrente contiene tre file, A, B, C.. Supponiamo che A occupi nell'ordine i blocchi 6,8,4,2; B occupi 5,9,12; C occupi 10,3,13. La directory (FAT) sarà
così organizzata (semplificando):
Nome
file
A
del
Primo blocco
6
97 - Tecno1 rel. 17.03.17
B
5
C
10
Quanto occupa una FAT? Troppo?!
Esempio: hard disk da 20 GB, blocchi di 1KB, 20M blocchi, indirizzi di blocco su non meno di 3 byte (o meglio, su 4 byte)
è la FAT occupa 80MB. Per velocizzare gli accessi, la FAT deve stare in memoria, quindi… servono 80 MB di RAM solo per la FAT!!!
Il problema e' dovuto al fatto che si mantengono tutte assieme le informazioni di tutti i file.
Un esempio di organizzazione gerarchica di una directory in DOS:
ciascuna entry occupa 32 bytes ed è così organizzata:
First Block No. è il puntatore alla FAT che individua il primo blocco del file
La root directory ha dimensione fissa per ogni periferica.
Le directory sotto root sono file di dimensione arbitraria e quindi possono contenere un numero qualsiasi di file
Assegnazione indicizzata
i-node
98 - Tecno1 rel. 17.03.17
()
● Si usa uno schema combinato per individuare i blocchi dati che compongono un file
● 10 blocchi sono indicizzati direttamente
● 1 indirizzamento indiretto singolo punta ad un blocco che invece di contenere dati contiene indirizzi di altri blocchi
● 1 indirizzamento indiretto doppio
● 1 indirizzamento indiretto triplo
Quanto può essere grande un file con i-node?
Consideriamo un blocco di 1 KB e un sistema di indirizzamento di 4 byte sia all’interno del file che nel i file system
8. ACCESSO DIRETTO: 10 blocchi = 10 KB
9. ACCESSO INDIRETTO SINGOLO: 1 blocco può contenere 256 indirizzi
o Quindi altri 256 KB di blocchi dati indirizzabili
10. ACCESSO INDIRETTO DOPPIO:
o 256 blocchi che contengono 256 indirizzi ognuno…256^2 = 65.536 KB (64 MB)
11. ACCESSO INDIRETTO TRIPLO: 256^3 = 16.777.216 KB (16 GB)
o Ma… con 4byte si indirizzano al massimo 4 GB!!!
Quanti blocchi posso indirizzare?
Consideriamo un blocco di 4 KB e un indirizzo di 8 byte sia all’interno del file che nel i file system
•
ACCESSO DIRETTO: 10 blocchi = 40 KB
•
ACCESSO INDIRETTO SINGOLO: 1 blocco può contenere 512 indirizzi.

Quindi altri 2 MB di blocchi dati indirizzabili
•
ACCESSO INDIRETTO DOPPIO:

512 blocchi che contengono 512 indirizzi ognuno… 512^2 = 262144 blocchi = 1 GB
•
ACCESSO INDIRETTO TRIPLO: 512^3 = 512 GB

Anche se con 8 byte potrei indirizzare TeraBytes…513 GB + 2 MB + 40 KB
Un esempio di organizzazione delle directory in Unix: organizzazione gerarchica,
ciascuna directory è un file contenente un numero arbitrario di entry, ogni entry è così fatta:
E' una organizzazione particolarmente semplice perchè tutte le informazioni sul file sono contenute nell'I-Node.
Si consideri il path usr/ast/mbox, si vuole individuare l'i-Node di tale file (e quindi il suo contenuto) secondo il seguente percorso:
99 - Tecno1 rel. 17.03.17
Dalla directory /usr/ast si ricava che l'i-Node di mbox e' il numero 60.
NTFS
Nel modello FAT i dati immagazzinati all’interno di un file vengono registrati con l’approccio di un’unica unità. In contrasto con questa filosofia, NTFS usa diversi
data stream per formare un file. Ciascun file in NTFS è rappresentato per mezzo di un record nella MFT (Master File Record).
NTFS riserva i primi 16 record della tabella per informazioni speciali:

descrizione MFT

MFT mirror del precedente record per eventuale MFT record corrotto

Log usato per il file recovery

Il settimo record e i successive sono usati per file e directory (visto come file da NTFS) sul dico.
MTF alloca un certo numero di ammontare di spazio per ciascun file. Gli attributi del file sono descritti all’interno del MFT.
File piccoli (1500 byte o inferiori) sono contenuti internamente al MFT:
Nota: NTFS può supportare file più grandi e in maggior numero rispetto a FAT32 e fornisce caratteristiche di sicurezza più flessibili per documenti e cartelle. Le
partizioni possono essere convertite da FAT32 a NTFS usando l'utility CONVERT.EXE. I tal modo si disporrà dei vantaggi aggiuntivi relativi alla sicurezza di NTFS.
Per riportare una partizione NTFS al formato FAT32, bisogna riformattare la partizione, ripristinando il contenuto da un backup.
Windows : estensioni dei file e attributi
In Windows i documenti sono organizzati in una struttura di directory. Il livello radice della partizione Windows è normalmente etichettata come disco C:\.
Successivamente c'è un insieme iniziale di directory predefinite, denominate cartelle, per il sistema operativo, le applicazioni, le informazioni sulla configurazione
e i dati. Dopo l'installazione iniziale, gli utenti possono aggiungere applicazioni e dati in qualsiasi directory essi scelgano.
FAT32 e NTFS di Windows hanno file e cartelle con nomi la cui lunghezza massima è pari a 255 caratteri non case-sensitive.
L’estensione del file puo essere da 1 a 4 caratteri(.doc.,.txt,.html,..). Gli attributi individuano le caratteristiche:Le estensioni di nomi di file, più comunemente
utilizzate sono:
.doc - Microsoft Word
100 - Tecno1 rel. 17.03.17
.txt - solo testo ASCII
.jpg - formato per immagini
.ppt - Microsoft PowerPoint
.zip - formato compresso
L'organizzazione delle directory mantiene un insieme di attributi per ogni file che controlla come il file possa essere visualizzato o modificato.
Questi sono gli attributi più comuni dei file (c\>attrib /?):
R - Il file è di sola lettura.
A - Il file sarà archiviato al successivo backup del disco.
S - Il file è contrassegnato come file di sistema ed un messaggio di avviso viene mostrato in caso di tentativo di cancellazione o modifica del file.
H - Il file è nascosto quando si visualizza il contenuto della cartella.
I – da indicizzare (Vista e 7)
L'equivalente di Windows del comando ATTRIB si ottiene cliccando col tasto destro del mouse in Windows Explorer e scegliendo Proprietà.
NOTA:
Sono visualizzabili da cmd->attrib, oppure in Gestione Risorse (dopo aver dato Show Hidden Files). Per le cartelle è possibile condividerle e configurarne i
permessi (tasto DX->Proprietà->Autorizzazioni
Per vedere le proprietà di un file in Windows Explorer, bisogna prima attivare l'opzione "Visualizza cartelle e file nascosti" di Windows Explorer. A tal proposito,
usare il seguente percorso:
Tasto destro su Start > Esplora > Strumenti > Opzioni Cartella > Visualizzazione
NTFS e FAT32
Il comando c:\>convert c:/fs:ntfs trasforma un disco FAT32 in NTFS.
NOTA: Dopo aver istallato un PC campione si lancia il comando sysprep.exe e si fa una immagine del disco di sistema: l’immagine serve a configurare altri PC
clonando il il disco campione con programmi quali Ghost. E’ possibile mettere anche una copia del CD di istallazione in rete e usare RIS (remote Installation
Service). I PC client devono essere avviati da rete con PXE-Pre-boot eXecution Environment o un disco di boot remoto.
101 - Tecno1 rel. 17.03.17
Protezione e sicurezza
Un aspetto sempre piu’ importante nella gestione dei sistemi operativi è quello relativo alla protezione e alla sicurezza, soprattutto in relazione all’ uso di un
calcolatore facente parte di un sistema distribuito.
Se un sistema di calcolo ha più utenti e consente che i processi siano eseguiti in modo concorrente, i diversi processi devono essere protetti dalle attività degli
altri processi. Per tale ragione, CPU, memoria e altre risorse devono essere controllate .
Protezione
Ricordiamo che un Sistema di Calcolo è un insieme di processi e oggetti, cioè elementi hardware come CPU, memoria, stampanti, dischi ed oggetti logici come
file, semafori e programmi.
Questi oggetti devono essere protetti contro tutti gli abusi .
Il ruolo della protezione è quello di fornire un meccanismo per imporre dei criteri che controllino l’uso delle risorse.
In altri termini, a un processo deve essere consentito l’accesso alle sole risorse di cui ha l’autorizzazione e deve usare solo le risorse di cui ha bisogno per svolgere
il proprio compito.
Un diritto di accesso è un permesso per eseguire una operazione su un oggetto.
Il processo opera all’interno di un Dominio di Protezione che specifica a quali risorse il processo può accedere. Un dominio è, perciò, un insieme di diritti di
accesso ed è costituito dalla coppia ordinata: nome dell’oggetto, insieme dei diritti di accesso, cioè quali operazioni possono essere compiute su quell’oggetto. Un
dominio si può realizzare in vari modi, ad esempio in Linux il dominio è associato all’utente: in questo caso l’insieme degli oggetti a cui si può accedere, e il modo,
dipende dall’identità dell’utente.
Spesso il modello di protezione è simile a una matrice di accesso simile a quella sottostante:
file 1
file 2
file 3
stampante
Dominio 1
read
Dominio 2
execute
print
Dominio 3
read, write
read , write
Spesso i sistemi reali sono limitati e consentono limitazione solo per i file: Linux fornisce, per ogni file, le protezioni per lettura, scrittura ed esecuzione distinte
per proprietario, gruppo o chiunque.
La JVM di Java fornisce un controllo più selettivo e personalizzato dei processi, rispetto al sistema operativo.
Sicurezza
Le informazioni presenti in un sistema di calcolo (codici e dati), così come tutte le altre risorse, devono essere protette da accessi non autorizzati, distruzioni,
alterazioni, modifiche accidentali.
Si dice che un sistema è Sicuro se alle sue risorse si accede solo nei modi previsti.
Le alterazioni alla sicurezza possono essere dolose o accidentali.
Per proteggere il sistema occorre agire su alcuni fattori:

fisico: protezione fisica contro i furti

umano: porre attenzione a fornire accesso ad utenti che forniscono l’accesso ad intrusi

rete: cercare di ridurre la possibilità di intercettazione dei dati che transitano in rete

sistema operativo: il sistema deve proteggere se stesso dalle violazioni accidentali o
intenzionali
Qui tratteremo le problematiche relative alla sicurezza del sistema operativo.
Autenticazione (controllo dell’accesso) degli utenti
Per i S.O. il principale problema relativo alla sicurezza riguarda l’autenticazione: si tratta di stabilire se un utente o un sistema siano effettivamente coloro che
dichiarano di essere.
Dati di sicurezza rubati o persi possono consentire più attacchi e necessitano di più schemi di autenticazione.
Nessuna tecnica offre completa sicurezza di autenticazione, neanche quelle Biometriche (impronte digitali, impronte vocali, mappatura della retina).
Ci sono molti tipi di meccanismi di autenticazione, ma i più usati sono:
102 - Tecno1 rel. 17.03.17
conoscenza dell’utente (cosa sai) : parola d’ordine (password), ID, PIN
oggetti posseduti (cosa hai): una chiave, una SmartCard
attributo dell’utente (cosa sei): : impronta digitale o di retina (tecniche biometriche), firma
Riferiamoci al metodo piu’ diffuso: la password, che si possono considerare come casi particolari di chiavi. La password puo’ essere vulnerabile. Due modi
consueti di individuare la parola d’ordine si basano sulla conoscenza dell’utente o sulla forza bruta, cioè provare tutte le possibili combinazioni di lettere, finchè si
scopre la password. Il SO può anche cifrare le parole d’ordine, ma poi non ha più il controllo. Si possono usare parole d’ordine accoppiate o monouso.
La login o la password sono considerate generalmente autenticazioni deboli.
Forti autenticazioni si ottengono combinando tra loro due diversi tipi di autenticazione. L'effettivo livello di sicurezza dipende ovviamente dal contesto, perché un
SmartCard può essere rubata, e le credenziali di login possono non essere difficili da individuare.
Minacce ai programmi
Si definisce malware un qualsiasi creato con il solo scopo di causare danni più o meno gravi al su cui viene eseguito.
Se un utente usa un programma scritto da un altro , si possono verificare vari tipi di abuso:
cavalli i Troia: le funzionalità sono nascoste all'interno di un apparentemente utile; è dunque l'utente stesso che installando ed eseguendo un certo programma,
inconsapevolmente, installa ed esegue anche il codice trojan nascosto.
: sono parti di codice che si diffondono copiandosi all'interno di altri , o in una particolare sezione del , in modo da essere eseguiti ogni volta che il infetto viene
aperto. Si trasmettono da un a un altro tramite lo spostamento di file infetti ad opera degli utenti.
(verme): sfruttano dei difetti () di alcuni per diffondersi automaticamente. Genera copie di se stesso logorando le risorse del sistema fino a farlo collassate. (cfr
l’internet worm di Robert Morris dotato di un rampino di arrembaggio e di un programma principale)
: che vengono usati per raccogliere informazioni dal sistema su cui sono installati e per trasmetterle ad un destinatario interessato. Le informazioni carpite
possono andare dalle abitudini di navigazione fino alle password e alle di un utente.
: questi si occupano di gestire la connessione ad tramite la normale linea telefonica. Sono malware quando vengono utilizzati in modo truffaldino, modificando il
numero telefonico chiamato dalla connessione predefinita con uno a tariffazione speciale, allo scopo di trarne illecito profitto all'insaputa dell'utente.
(“dirottare"): questi programmi si appropriano di applicazioni di navigazione in rete (soprattuto ) e causano l'apertura automatica di indesiderate.
Phishing ("spillaggio (di dati sensibili)") è una attività illegale che sfrutta una tecnica di (ingegneria sociale (social engineering) si intende lo studio del
comportamento individuale di una persona al fine di carpire informazioni.), ed è utilizzata per ottenere l'accesso a informazioni personali o riservate con la
finalità del mediante l'utilizzo delle comunicazioni elettroniche, soprattutto messaggi di fasulli o messaggi istantanei, ma anche contatti telefonici. Grazie a
questi messaggi, l'utente è ingannato e portato a rivelare dati personali, come numero di conto corrente, numero di carta di credito, codici di identificazione, ecc
103 - Tecno1 rel. 17.03.17