Professional Documents
Culture Documents
RIASSUNTO
Un sistema di elaborazione non può essere più affidabile e sicuro del software che su di esso risiede.
La comunità scientifica non ha tuttavia ancora ben definito la giusta miscela di fault-avoidance e di
fault-tolerance che il software dovrebbe possedere per far fronte a malfunzionamenti dovuti ad erro-
ri di progetto o di debugging.
Questo scritto tratta delle eccezioni, un argomento che partecipa di entrambi gli aspetti di cui sopra.
Delle eccezioni vengono considerati la definizione, i modelli realizzativi e gli schemi di intercetta-
zione e di gestione: il tutto con particolare riguardo alla terminologia e ai metodi più largamente
adottati o più promettenti per il futuro.
ABSTRACT
A computing system cannot be more reliable and safer than the software residing on it. The scientif-
ic community have not yet well defined the right mixture of fault-avoidance and fault-tolerance the
software should have to front bad working because of design or debugging errors.
This paper deals with the exceptions, a topic comprehensive of above both arguments. Of the ex-
ceptions are considered: the definition, models of implementation, mechanisms for catching and
managing. The whole with detailed interest into the terminology and the methods more widely ad-
opted or more promising for the future.
----
1 DEFINIZIONE DI ECCEZIONE
La necessità di definire che cos'è un'eccezione prima di inserire in un linguaggio meccanismi che la
riguardano può sembrare ovvia. Nella realtà, come spesso accade, le cose sono andate diversamen-
te. Infatti i primi tentativi di dotare i linguaggi di strumenti per l'intercettazione e il trattamento delle
eccezioni sono stati effettuati senza che i progettisti disponessero di una definizione esplicita a cui
fare riferimento.
Questo modo di procedere, che può aver avuto inizialmente qualche giustificazione, non può essere
ulteriormente mantenuto a causa dei risultati fortemente discutibili che ha prodotto.
1 Anche se questo punto di vista è stato sostenuto da Goodenough in un lavoro fondamentale sulle eccezio-
ni [GOOD75].
2 Ad esempio i monitor del Concurrent Pascal [HANS75].
3 Ad esempio le coroutine del Simula [LAMP81]. Una coroutine è un'unità di programma in grado sospen-
dersi e di passare il controllo a un'altra coroutine che riprende l'esecuzione dal punto in cui a sua volta si
era sospesa. Per la definizione di “unità di programma” v. 2.1.
2 MODELLO REALIZZATIVO
La definizione di eccezione dovrebbe essere accompagnata da un modello di realizzazione. È op-
portuno che tale modello sia definito in modo esplicito: infatti l'esperienza nel campo dei linguaggi
di programmazione ha mostrato che i progettisti tendono comunque a costruirsi un proprio modello
mentale che può facilmente risultare incoerente e inadeguato; in tal caso il minimo che può accade-
re è un'esagerazione delle difficoltà realizzative.5
Naturalmente occorre tenere presente che potrebbe essere la definizione del linguaggio o addirittura
la definizione stessa di eccezione a precludere la possibilità di trovare un modello realizzativo con-
cettualmente semplice.6
Un esempio di linguaggio recente che crea difficoltà nella definizione di un modello semplice di ec-
cezione è Ada. Ciò è dovuto alle caratteristiche stesse del linguaggio che, anziché essere costituito
da pochi costrutti componibili, ne comprende invece parecchi specializzati e, spesso, non necessari
[DISA83] [KROG86].
4 A riprova di ciò basti pensare ai concetti che esso incorpora: multi-tasking, puntatore, area, offset, varia-
bile basata; senza contare che le funzioni intrinseche UNSPEC e ADDR, accoppiate a puntatori liberi
contenenti indirizzi di memoria, consentono addirittura di indirizzare la memoria centrale.
5 Come esempio si possono ricordare le difficoltà incontrate nella realizzazione dei primi compilatori del-
l'Algol 60, nonostante il linguaggio fosse stato definito con una precisione sconosciuta prima d'allora
(1960-1963). Solo quando fu noto ai progettisti il modello realizzativo (dovuto a Dijkstra) basato sul run-
time stack, la realizzazione si semplificò enormemente.
6 Tornando alla realizzazione dei compilatori non è un mistero che, mentre per alcuni linguaggi si sono po-
tuti trovare semplici modelli realizzativi (a stack per l'Algol, a stack e heap per il Pascal, a stack nidificati
interagenti per il Simula), per altri non sono noti modelli "puliti": ad esempio per il PL/I e per Ada. Non è
da escludere che, in entrambi i casi, l'enfasi posta sull'universalità del linguaggio abbia messo in ombra le
modalità di realizzazione.
7 Ulteriori precisazioni esulano dallo scopo di questo scritto e possono essere trovate, ad esempio, in [HO-
chiama
Y Z
segnala
chiama chiama
X Y Z
segnala segnala
9 A meno che non si adotti una pura gestione di default (v. 5.3).
10 A proposito di Ada vale forse la pena di osservare che vengono continuamente proposte modificazioni
alla definizione del linguaggio [SCHW81] [WEGN83] e in particolare ai suoi meccanismi sulle eccezioni
[DISA83]. Il suo manuale di riferimento, peraltro, si mantiene piuttosto vago sull'argomento.
11 Nel senso delle classi del Simula.
12 Come controesempio si consideri che in Ada, mancando tali dichiarazioni esplicite, la selezione degli
handler è possibile solo in esecuzione, pur essendo essi associati staticamente alle unità di programma
(associazione "quasi-statica"). Per una discussione dettagliata sull'argomento si veda [HELI84].
5.1 La segnalazione
Per quanto riguarda la segnalazione, supponendo di adottare il modello di associazione statico con
propagazione ad un solo livello, due metodi particolarmente efficienti per la selezione dell'handler
appropriato sono quelli basati sulle "branch table" e sulle "handler table".
Il primo metodo, che cerca di ottimizzare la velocità di esecuzione, associa ad ogni invocazione di
un'unità di programma una tabella di salto contenente un elemento per ogni eccezione che può esse-
re sollevata nell'unità (eventualmente un solo elemento se si adotta un'unica gestione di default).
Il secondo, che cerca di minimizzare l'occupazione di memoria, associa invece ad ogni handler una
tabella contenente sia le regole di visibilità dell'handler da parte delle varie unità di programma, sia
una lista delle eccezioni che l'handler può gestire. Questo metodo è da preferirsi qualora il numero
di handler sia molto minore del numero di invocazioni (ciò che normalmente si verifica).
Entrambi i metodi sono stati sperimentati in diverse versioni del linguaggio CLU [LISK79]; l'ultimo
è quello adottato nel linguaggio CHILL [IMPA82].
BIBLIOGRAFIA
[ADAL84] "Ada: Language, Compilers and Bibliography", Cambridge University Press, pagg.
11.1-11.12, Cambridge, 1984.
[ANDE76] T. Anderson, R. Kerr, "Recovery Blocks in Action", 2nd International Conference on
Software Engineering, Proceedings, Atlanta, 1976.
[APPE84] W.F. Appelbe, K. Hanse, "A Survey of Systems Programming Languages: Concepts and
Facilities", Software Practice and Experience, 15(2), 1985.
[BUTT84] A. Butti, A. Lora, G.C. Macchi, "The FSM and Message Communication: Impact on
Software Testing", IEEE International Conference on Communications - ICC'84, Proceedings,
Amsterdam, 1984.
14 La sequel è un'unità di programma che, al termine dell'esecuzione, trasferisce il controllo alla fine dell'u-
nità di programma nella quale è dichiarata come unità locale.
INDICE
RIASSUNTO........................................................................................................................................1
ABSTRACT.........................................................................................................................................1
1 DEFINIZIONE DI ECCEZIONE.....................................................................................................1
1.1 Che cos'è un'eccezione..............................................................................................................1
1.2 Che cosa un'eccezione non è.....................................................................................................2
1.2.1 Una breve digressione sul PL/I.........................................................................................3
2 MODELLO REALIZZATIVO........................................................................................................3
2.1 Modello di propagazione delle eccezioni.................................................................................3
3 ASSOCIAZIONE DEGLI HANDLER ALLE UNITÀ DI PROGRAMMA ..................................5
4 ESISTENZA DELL'UNITÀ SEGNALANTE DOPO LA SEGNALAZIONE...............................5
5 GESTIONE DELLE ECCEZIONI ..................................................................................................6
5.1 La segnalazione.........................................................................................................................6
5.2 La recovery di stato e la recovery cache...................................................................................6
5.3 La gestione di default e i recovery block..................................................................................7
5.4 La gestione programmata..........................................................................................................8
6 DISABILITAZIONE DELLE ECCEZIONI....................................................................................8
BIBLIOGRAFIA..................................................................................................................................8