STUDIO DI FUNZIONI

Schema per lo studio di funzioni a una variabile (x) by Davide Marrazzo:

ROMANTICISMO

L'aggettivo "romantico" compare per la prima volta in Inghilterra, verso la metà del 600, con significato spregiativo per indicare quanta fantasia e falsità era presente nei romanzi cavallereschi. Viene ripreso poi in Germania a fine 700, dagli scrittori della rivista Athenaeum, per definire la cultura moderna in netta contrapposizione con quella classica. Secondo costoro la sensibilità classica è caratterizzata da equilibrio e armonia, mentre quella moderna da squilibrio e una mancanza di qualcosa, caratteristiche della vita dell'uomo romantico.
Oggi con il termine romanticismo indichiamo il movimento culturale che caratterizza la prima metà dell'800, appunto durante l'espansione della rivoluzione industriale, l'affermazione del ceto borghese, l'età della Restaurazione e dei movimenti nazionalisti. Nell'uso comune questo termine viene usato per indicare una generica inclinazione al sentimentalismo e alla fantasticheria.
Uno dei tratti caratteristici della cultura romantica è l'elaborazione dell'idea di nazione, l'altro è la riscoperta del Medioevo. Quest'ultimo è visto come nascita e principio delle nazioni moderne. In campo artistico e letterario c'è una netta contrapposizione tra Romanticismo e Classicismo.

ROMANTICISMO           vs           CLASSICISMO
-storicità dell'arte                              -seguire delle regole e dei modelli
-soggettività del gusto                      -tutto segue degli standard considerati perfetti
-rifiuto delle regole
-originalità

Nel Romanticismo è fondamentale la valorizzazione dell'individuo:

INDIVIDUO
-eroe romantico
-conflitto con la società
-stato di malessere, insoddisfazione:
                               -ribellione
                               -vittimismo

TABELLE DELLE PAGINE A PIÙ LIVELLI

Le tabelle delle pagine a più livelli consistono nell'utilizzare tabelle delle pagine di livello superiore, che contengono un riferimento ad altre tabelle di livello inferiore e così via. In poche parole, se abbiamo che nella tabella di 1° livello (non è un sayan) ci sono 10 elementi, ognuno di questi servirà come riferimento per puntare ad una tabella specifica di secondo livello, dove quest'ultima potrà contenere anch'essa riferimenti ad altre tabelle, oppure potra essere di "ultimo livello", cioè contenere riferimenti a pagine fisiche e terminare così la catena di tabelle.
Il vantaggio di utilizzare questo metodo per gestire le pagine, sta nel fatto che quando un processo viene mandato in esecuzione, si caricano in memoria solo le tabelle necessarie alle pagine di quel processo, lasciando quelle che non servono fuori dalla memoria. In questo modo, come si può notare, si ha un aumento di velocità nel raggiungere la pagina fisica ed anche un risparmio di spazio occupato, in memoria, dalle tabelle.

MEMORIA SEGMENTATA

Fino ad ora abbiamo visto una memoria virtuale con un singolo spazio di indirizzamento che parte dall’indirizzo 0 fino ad arrivare all’indirizzo massimo N.

Con la memoria segmentata, invece, viene divisa la memoria in segmenti.

Ogni segmento parte dell’indirizzo 0 a può arrivare fino ad una grandezza massima n anche se non è detto che ci arrivi: il segmento ha il grande vantaggio di essere espandibile e contraibile a seconda delle necessità.

Lo stack, ad esempio, può espandersi se si scrive una variabile al suo interno e si contrae se si preleva una variabile.

Ogni segmento è completamente indipendente dagli altri: in questo modo si può espandere e contrarre come vuole senza andare ad intaccare o “disturbare” altri segmenti di memoria (cosa che succede con una memoria non segmentata portando anche gravi problemi e sprechi di tempo dovuti alla continua rilocazione delle pagine).

Per accedere ad un’istruzione l’indirizzo di una memoria segmentata deve essere diviso in numero di segmento e offset.

Siccome i segmenti sono distini e separati tra di loro, essi sono molto comodi: immaginiamo di dover trovare un alunno in una scuola con 10.000 iscritti (in questo caso l’alunno è una procedura, una funzione così via...): la ricerca sarebbe molto più veloce se conoscessimo (prima del nome e del cognome dell’alunno) anche la classe dello studente.

Basterebbe collegare l’informazione della classe e dell’alunno e andare a pescare la persona giusta, cosa che sarebbe molto più laboriosa se non conoscessimo la classe perchè dovremmo andare a cercare il nome tra 10.000 studenti.

Un’altro vantaggio, molto importante su grossi sistemi o durante la progettazione di grossi programmi, è la possibilità di compilare singole procedure e non tutto il programma. Se in un nostro programma modifichiamo un procedura, non andrà ricompilato tutto il codice, perchè sono stati modificati gli indirizzi di memoria solo della procedura che appartiene ad un segmento, mentre tutti gli altri segmenti sono rimasti invariati.

Un altro vantaggio della memoria segmentata è sicuramente la facilitazione della protezione: siccome ogni segmento contiene una serie di oggetti dello stesso tipo (un segmento contiene, ad esempio, solo dati o stack, ma non entrambi), posso specificare anche che tipo di protezione tenere per quel segmento specifico specificando permessi di lettura/scrittura/esecuzione.

In un sistema segmentato, la protezione ha senso per il semplice motivo che il programmatore è conscio dell’esistenza dei segmenti e sa con precisone cosa ci sia all’intero di ogniuno, cosa che non succede con un sistema a singolo spazio di indirizzamento paginato.

Le librerie grafiche di un computer, che solitamente sono molto estese e pesanti, verranno messe in un segmeno con protezione bassa in modo da poterle condividere con altri programmi (in questo modo gli altri programmi eviteranno di compilare le proprie librerie grafiche perchè utilizzano quelle del computer).

La sostanziale differenza tra paginazione e segmentazione è che i segmenti non hanno una dimensione fissa.

Quando i segmenti vengono caricati o scaricati dal disco molte volte, si può creare una frammentazione esterna e per questo, ogni tanto, il sistema operativo procederà alla compattazione.

WORKING SET

Una cosa molto interessante da notare è che ogni proceso fa riferimento ad una piccola quantità di pagina e non a moltissime pagina tutte insieme.

Un compilatore a più passate, per esempio, fa riferimento a poche pagine di memoria per ogni passata.

L’insieme della pagine che vengono utilizzate correntemente da un processo si chiama working set (o zona di lavoro).

Il working set dovrebbe essere caricato tutto in memoria in modo da evitare dei fault di pagina continui che porterebbero al rallentaento della pagina (thrashing).

Cosa succede su un processo viene scaricato in memoria e poi deve riprendere l’esecuzione?

In teoria basterebbe semplicemente non far nulla. Il processo genererà moltissimi fault di pagina fino a che il suo working set non sia stato caricato in memoria per poi riprendere l’esecuzione.

Il problema sta nel fatto che il computer potrebbe metterci alcuni millisecondi per gestire un fault di pagina. E se abbiamo migliaia di fault?

La soluzione è implementata in molti sistemi operativi moderni: viene tenuta traccia dei working set di ogni processo e non si permette al processo di ricominciare a lavorare prima che il suo working set non sia stato caricato in memoria in modo da evitare fault di pagina (questa procedura si chiama prepaging).

Il working set è sostanzialmente l’insieme di pagine usate nei k riferimenti di memoria più recenti.

ALGORITMI DI RIMPIAZZAMENTO DELLE PAGINE

Quando si genera un fault di pagina, il Sistema Operativo deve scegliere quale pagina scaricare dalla memoria.

È evidente che la scelta non può essere casuale perchè si rischierebbero rallentamente pesanti nella macchina.

I progettisti di computer hanno individuato un algortimo ottimale (che non può essere realizzato) per poi tentare di riprodurlo.

L’algoritmo ottimale dice che ogni pagina deve essere contrassegnata con il numero di istruzioni macchina che vengono eseguite prima che a quella pagina si faccia riferimento.

La pagina con il numero più alto viene scaricata.

Ovviamente questo algoritmo ha un implementazione impossibile perchè è impossibile determiare il numero di istruzioni che occorrono prima del riferimento alla pagina.

I progettisti hanno allora cercato degli algortimi che potessero aiutare veramente durante la progettazione di un computer:

Il primo algoritmo chiamato NRU ha bisogno, per essere utilizzato, di due bit: un bit R che viene messo a 1 quando si fa un riferimento alla pagina (lettura o scrittura) e un bit M che viene messo a 1 quando si fa una scrittura alla pagina.

Periodicamente, il bit R viene rimesso a 0 dal sistema operativo mentre l’M viene mantenuto ad 1 se la pagina è stata modificata.

Il sistema operativo, in questo modo, è in grado di classificare ogni pagina in 4 categorie:

Classe 0: non usata e non modificata (0,0)

Classe 1:non usata, modificata (0,1)

Classe 2: usata, non modificata (1,0)

Classe 3:usata,modificata(1,1)

Quando si genera un fault di pagina, il sistema operativo scarica dalla RAM una pagina casuale presa dalla classe più bassa non vuota.

Un altro algoritmo di rimpiazzamento è detto algoritmo FIFO.

É un algoritmo di facile implementazione, infatti, quando si genera un fault di pagina, viene scaricata dalla RAM la pagina che è presente da più tempo in memoria.

Il problema di questo algoritmo è evidente: anche se una pagina è vecchia, cioè da molto tempo in memoria, non vuol dire che sia inutile.

Una combinazione tra NRU e FIFO è l’algoritmo della seconda opportunità: quando si va in contro ad un fault di pagina, si va a cercare l’elemento più vecchio, cioè quello in coda alla lista.

Una volta che abbiamo trovato l’elemento più vecchio, si controlla il suo bit R. Se è a 0, vuol dire che la pagina è vecchia e non usata e allora la pagina viene scaricata su disco.

Se il bit R è a 1, viene messo a 0 e la pagina viene spostata in testa alla lista come se fosse stata appena caricata.

A questo punto si cotinua a cercare una pagina in fondo alla lista con bit R a 0.

L’algorimo dell’orologio consiste in questo: si mantiene una lista circolare di pagina con la lancetta che punta su una pagina. Se ad un fault di pagina la lancetta punta su una pagina con bit R a 0, la pagina viene scaricata, viene portata la lancetta avanti di uno e la pagina che deve entrare in memoria viene sostituita alla pagina appena scaricata.

Se il bit R e a 1, viene messo a 0 e la lancetta spostata in avanti fino a quando non si trova una pagina con bit 0.

Una buona approssimazione dell’algoritmo ottimale e quella offertaci dall’algoritmo LRU.

Questo algoritmo consiste nello scaricare dalla memoria la pagina non usata da più lungo tempo.

Un modo per implementare la LRU e quello di avere un contatore a 64 bit e che ogni pagina contenga abbastanza spazio per memorizzare il contenuto del contatore.

Dopo ogni riferimento in memoria, il valore del contatore viene memorizzato nella pagina a cui si è fatto riferimento.

Quando si va in contro ad un fault di pagina, viene scaricata dalla memoria la pagina con il valore del contatore più basso (la pagina corrispondente al contatore più basso e la pagina usata meno di recente).

Un altro metodo per implementare la LRU e quello di mantenere una tabella n*n (n numero delle pagine fisiche). Quando si fa un riferimento ad un pagina k , viene messa a 1 tutta la riga k e a 0 la colonna k.

Quando si genera un fault di pagina si controlla il valore binario di ogni riga: la riga con il valore binario più basso è quella usata meno di recente.

Queste implementazioni della LRU vengono eseguite via hardware. Il problema è che nessuna macchina possiede tale hardware.

Per questo si è cercato di simulare la LRU via software e si è riusciti con l’NFU.

Ad ogni pagina è associato un contatore e ad ogni interruzione di clock viene sommato il contatore al bit R della pagina.

Quando si verifica un fault di pagina, viene scelta la pagina con il contatore più basso.

Dopo varie simulazioni si è notato che anche questo algoritmo non è il massimo dell’efficienza, perchè non dimentica mai nulla e potrebbe essere che vengano scaricate su disco delle pagine che servano nell’immediato futuro.

Una modifica dell’NFU, chiamata algoritmo dell’invecchiamento, permette una resa ottimale e una buona approssimazione all’algoritmo ideale.

Come implementare tutto ciò?

Ogi pagina ha una serie di bit (8) che all’inizio vengono messi tutti a 0. Dopo ogni ciclo di clock, gli 8 bit vengono shiftati a destra di una posizione e viene messa nella posizione ora vuota il bit R.

Quando si genera un fault di pagina viene scaricata la pagina con la serie di bit più bassa.

TLB (Memoria Associativa)

Osservando l’utilizzo della memoria di un calcolatore, potremmo notare che la maggior parte dei programmi accede a poche pagine di memoria molto di frequente e non a molte pagine poco frequentemente.

Per sfruttare questa condizione vantaggiosa, i progettisti hanno creato una sorta di MMU ridotta ad accesso parallelo chiamata TLB.

All’interno della TLB vengono salvati alcuni dati relativi ad ogni pagina virtuale usata spesso.

Quando arriva alla MMU un indirizzo virtuale, prima di fare un controllo sulla tabella della pagine, viene controllato ogni elemento della TLB simultaneamente e se nella TLB è presente questo elemento, viene data subito la pagina fisica, senza bisogno di accedere alla lenta tabella delle pagine.

Se invece la pagina virtuale non è presente nella TLB, si genera una page miss, viene cercata nella tabella delle pagine la pagina virtuale, viene scaricata una pagina dalla TLB e rimpiazzata con la pagina appena trovata sulla tabella delle pagine.

MEMORIA VIRTUALE E MMU

Il ragionamento dietro alla memoria virtuale consiste nel fatto che un programma può essere più grande della memoria fisica.

Il programma viene diviso in modulo (overlay) e solo quelli necessari all’esecuzione vengono caricati in RAM mentre le restanti parti restano sul disco.

Un programma da 4 GB può girare tranquillamente su una memoria da 2GB scegliendo accuratamente quali 2GB mandare in esecuzione.

La memoria virtuale ora introduce anche il concetto di paginazione: la memoria viene divisa in partizioni dette pagine e ogni pagina è grande solitamentre 4 KByte.

In un sistema a 32 bit, ci sono 12 bit che servono per “muoversi” all’interno della pagina (2^12 = 4KB) e il restante 20 bit servono ad indicare la pagina a cui facciamo riferimento.

Da questo deduciamo che appunto con 12 bit di offset le pagine posso essere grandi massimo 4KB e che ci possono essere al massimo 2^20 pagine (1 milione di pagine).

(1 milione di pagine per 4KB l’una sono 4 giga).

Ora però l’indirizzo della pagina virtuale non corrisponde a quello della pagina reale.

Come risolvo questo problema? Sulla scheda madre c’è un componente chiamato MMU che fa da traduttore: prende l’indirizzo della pagina virtuale e lo trasfororma in indirizzo reale.

La MMU contiene appunto una tabella delle pagine che è compilata dal gestore della memoria. Il gestore della memoria, infatti, tiene conto delle pagine libere e è in grado di dire dove una pagina virtuale deve puntare sulla memoria reale.

Su un sistema a 32 bit, 12 bit vanno direttamente in memoria e 20 bit, invece, si fermano sulla MMU. Questi 20 bit compongono l’indirizzo virtuale della pagina richiesta, ma prima che la scheda di memoria onori la richiesta, questo indirizzo virtuale deve essere trasformato in indirizzo reale tramite la MMU.

Ovviamente in memoria virtuale abbiamo, ad esempio, 100 pagine virtuali, mentre in memoria reale sono 10 pagine.

Capiamo quindi che sono 10 pagine virtuali avranno un corrispettivo in memoria reale. Ogni pagina virtuale ha quindi un bit che che messo a 0 vuol dire che la pagina non è mappata, se è a 1 vuol dire che è mappata.

Cosa succede ora se per caso si deve accedere ad una pagina virtuale che non ha un corrispettivo nella memoria fisica?

In una situazione di questo genere si crea un fault di pagina: viene prelevata una pagina (algortimi di rimpiazzamento della pagine dopo) dalla memoria fisica, se è stata modificata viene riscritta su disco, altrimenti no.

Sulla sua pagina virtuale, viene messo un bit a 0 che sta a significare che quella pagina virtuale non ha più un corrispettivo nella memoria reale.

Ora viene presa la pagina virtuale a cui si deve accedere e viene scritta sopra la precedente pagina; si modifica la MMU per far puntare quella pagina virtuale a quella pagina fisica e viene messo un bit a 1 per dire che quella pagina virtuale ha un corrispettivo nella memoria reale.

Con un sistema a 32 bit, ci sono 2^20 pagine virtuali che corrispondono a oltre un milione di pagine virtuali.

L’indirizzo della pagina virtuale viene usato come indice della tabella delle pagine e il contenuto della corrispondente cella è l’indirizzo di memoria fisica.

In un sistema a 64 bit, il numero di pagine virtuali è 2^52 che sono moltissime.

Con così tante pagine virtuali, la velocità e la stabilità dal sistema sono seriamente compromesse e per questo si utilizzano metodi diversi per l’accesso alle istruzioni.

Un metodo è la tabella delle pagine inverse.

Nella tabella delle pagine normale, ci sono tante celle quante sono le pagine virtuali.

Nella tabella della pagine invertite, ci sono tante celle quante sono le pagine fisiche: la CPU emette un indirizzo a 32 bit, 12 di offset e 20 di pagina virtuale.

Al posto di andare all’indice dettato da 20 bit, si cerca nel contenuto delle celle il corrispettivo numero dei 20 bit e quando lo si trova si prende l’indice e quella è la pagina fisica.

Se non si trova l’elemento abbiamo un fault di pagina.

In sostanza le pagine fisiche fanno da indici per la tabella e quelle reali da contenuto.

POLITICHE DI GESTIONE DELLA MEMORIA

Quando la memoria viene gestita e allocata dinamicamente, è sempre bene tenere conto della memoria utilizzata e di quella non utilizzata.

Il primo modo di tracciare l’utilizzo della memoria è quello con le bitmap.

Viene creata una grande matrice formata da 0 e 1. La memoria viene divisa in piccole partizione e a ogni partizione viene associata una casella della bitmap. Se c’è 1 nella bitmap, la partizione è occupata, altrimenti è libera.

Il secondo metodo per tenere traccia dell’utilizzo della memoria è il metodo a liste: il sistema operativo tiene una lista concatenata di spazi liberi e occupati in memoria con le informazioni riguardanti la dimensione.

In ogni nodo della lista sono presenti tre informazioni: se la regione di memoria è libera, l’indirizzo di inizio e di fine di quella regione.

Quando spazi e buchi vengono ordinati nella lista in ordine di indirizzo, possiamo poi usare diversi algoritmi per allocarle la memoria ad un processo.

Il primo metodo è detto di first feet, cioè il gestore della memoria trova il primo buco sufficientemente grande per contenere il processo, divide il buco in 2 parti: uno spazio per il processo e uno spazio che diventa un altro buco più piccolo. Altri algoritmi sono il next feet, il best feet, worst feet e il quick feet.

SWAPPING

Lo swapping consiste nel caricare e scaricare in RAM un processo a seconda delle esigenze. Se un processo deve essere eseguito sul processore, Il processo viene mosso dal disco alla memoria, eseguito e poi riportato su disco per permettere ad altri processi di occupare quell’area di memoria.

Assistiamo quindi ad una gestione dinamica della memoria: le partizioni non hanno mai stesse dimensioni e la stessa posizione.

La gestione dinamica della memoria utilizzata nello swapping consente una maggiore flessibilità, ma implica anche una maggiore difficoltà a causa della continua rilocazione delle partizioni.

Una cosa molto importante è anche la quantità di memoria che va allocata per ogni processo: se ogni processo avesse una dimensione fissa, basterebbe allocare la quantità di memoria che serve, ne più ne meno.

Il problema sta nel fatto che spesso i processi si modificano in dimensioni e quindi è sempre meglio allocare una dimensione di memoria superiore per evitare problemi di segmentation fault.

RILOCAZIONE E PROTEZIONE

La multiprogrammazione porta con se anche due grandi problemi: la rilocazione e la protezione.

Quando compiliamo un programma viene generato un file binario contenente delle istruzioni. Supponiamo che la prima istruzione sia una chiamata ad una funzione in posizione 100 e che la partizione di memoria del processo inizi in posizione 350. Il processo dovrebbe eseguire l’istruzione in posizione 350 + 100 e non in posizione 100. Quindi il problema consiste nel trasformare l’indirizzo di memoria assoluto, in quello relativo alla proprio partizione di memoria. Il problema viene comunemente risolto semplicemente aggiungengo 350 durante la chiamata a quella istruzione. Questo però non risolve il problema della protezione, infatti si potrebbero creare delle istruzioni che utilizzino direttamente indirizzi assoluti e non relativi.

IBM risolse questo problema con 4 bit che definivano cosa si potesse fare in una determinata sezione di memoria. Il file che conteneva questi 4 bit si chiamava PSW.

Un’altro modo per risolvere entrambi i problemi era i registri di base e limite. In quello di base, era contenuto l’indirizzo dove iniziava la partizione e in quello di limite dove finiva la partizione: se durante la trasformazione da indirizzo assoluto a indirizzo relativo veniva sforato il limite sia positivamente che negativamente, il processo veniva killato.

Inoltre, ad ogni chiamata ad un indirizzo, veniva sommato all’indirizzo il registro base per trasformare da indirizzo assoluto a indirizzo relativo.

ORGANIZZAZIONE DELLA MEMORIA

L’organizzazione della memoria più avvenire così in due modi: con diverse code o in singola coda.

Nel primo caso tutti i processi “piccoli” si accodano dove c’è la partizione più piccola che possa contenere il singolo processo e lo stesso vale per i processi “grandi”. Il problema di questo modo di usare la memoria è che potrebbe accadere che la coda dei processi piccoli sia piena, mentre la coda dei processi grandi sia vuota: in questo caso i processi piccoli in fondo alla coda aspettano di essere caricati in memoria, mentre in realtà la memoria è quasi totalmente vuota perchè le partizioni grandi che dovrebbero contenere processi grandi sono vuote.

La coda singola è diversa, cioè viene creata una singola coda contenete processi grandi e piccoli.

Quando viene liberata una partizone di memoria, viene cercato nella coda il processo che sprechi meno memoria mettendosi in quella partizione.

Il problema di questo tipo di gestione della memoria è che i processi piccoli vengono discriminati mentre in realtà dovrebbero essere privilegiati.

GESTIONE DELLA MEMORIA (Introduzione)

Come sappiamo, all’interno di un computer esistono diversi tipi di memorie diverse per velocità, capacità e prezzo.

In un computer ideale, tutte le memorie sarebbero enormi, molto economiche e velocissime, ma dato che ciò non è possibile, i progettisti hanno deciso di creare diversi tipi di memoria: la Cache, molto veloce, molto piccola e molto costosa, la RAM, abbastanza capiente, abbastanza veloce e mediamente costosa e la memoria di massa, lenta, molto capiente e economica.

Il gestore della memoria ha il compito di gestire e organizzare le memorie nel modo più efficiente possibile, tenendo conto delle pagine di memoria usate e quelle non usate, compilando la tabella delle pagine nella MMU e svolgendo molti altri compiti che vedremo più avanti.

Nel caso di un sistema monoprogrammato (cioè che può eseguire un processo alla volta), la gestione della memoria è molto semplice, infatti, è possibile caricare in RAM un processo alla volta e fino a quando non viene portato a termine, esso non verrà scaricato dalla RAM.

In un sistema monoprogrammato ci sono tre diversi modi di gestire la memoria: il SO nella parte bassa della RAM, il SO in ROM, oppure il SO nella parte bassa della RAM e il gestore delle periferiche in ROM.

Ai giorni nostri, però, la monoporgrammazione non è più contemplata e si è passati alla multiprogrammazione, dove più processi risiedono in RAM in attesa di essere caricati ed eseguiti sulla CPU.

Il modo più semplice per realizzare la multiprogrammazione è dividere la memoria in blocchi fissi, magari di dimensioni diverse.

Quando un processo viene caricato in RAM, viene cercata la partizione più piccola disponibile che possa contenere il processo.

DEI SEPOLCRI (Ugo Foscolo)

Questo componimento fu scritto da Foscolo nel 1806, a seguito di una discussione con il letterario Pindemonte a cui è dedicata l'opera. È composto da 295 versi endecasillabi sciolti. Fu scritto in occasione dell'editto di Saint-Cloud, dove venne approvata una legge che imponeva di spostare i cimiteri(sepolcri) fuori dalle città e di rendere tutte le tombe uguali tra di loro. Foscolo sviluppa un ragionamento intorno al tema delle tombe, riflettendo sul perchè l'uomo ne abbia bisogno e sul loro valore simbolico.

Spezzoni letti in classe:
-IL VALORE AFFETTIVO DEI SEPOLCRI (pag.567)
Nella prima parte Foscolo esprime i suoi sentimenti puramente materialistici, in cui vuole risaltare come le tombe siano sostanzialmente inutili. Nella seconda parte, invece, sottolinea il valore delle tombe e di come servano all'uomo per mantenere vivo il ricordo dei suoi cari.
-LA FUNZIONE DELLE TOMBE DEGLI UOMINI ILLUSTRI (pag.575)
La vera capacità eternatrice del ricordo dei morti è data dalla poesia, che serve per continuare a mantenere vivo il ricordo nel tempo, le gesta e gli ideali degli uomini illustri, così che le generazioni future possano prendere spunto da essi.

I SONETTI (Ugo Foscolo)

Nei sonetti di Foscolo troviamo un maggior distacco più profondo dei propri sentimenti rispetto alle lettere di Jacopo Ortis, furono composti tra il 1798 e il 1803. Il linguaggio è sempre di tono elevato e letterario. I sonetti sono nati nel 1200 nella scuola siciliana; in quelli di Ugo Foscolo, troviamo molti enjambemant e 4 strofe formate da rime e versi endecasillabi.
I principali sono essenzialmente 4:
(Wikipediata)

-Alla Sera:
Nell'immobile silenzio della sera, quando ogni forma di vita si spegne, il silenzio suggerisce al poeta l'immagine della morte alla quale egli si rivolge con nostalgia, come se essa potesse portare solamente la pace. La morte non è più vista come una drammatica sfida al destino, come nell'Ortis, ma come un dolce perdersi nel nulla eterno che non è un disperato abbandono, ma è un comprendere in sé l'universo superando ogni angoscia e ritrovando la pace.

-A Zacinto:

A Zacinto ("Né più mai toccherò le sacre sponde") è uno dei sonetti più conosciuti di Ugo Foscolo. Zacinto, qui cantata dal poeta, non è solamente la sua patria reale ma soprattutto quella ideale. Come altri poeti romantici il Foscolo si protende alla Grecia classica nella quale vede, attraverso i suoi miti, l'incarnazione della bellezza e dell'armonia. Venere raffigura l'ideale della bellezza, Omero rappresenta la poesia che esalta i valori più alti dell'umanità e Ulisse non è altro che l'immagine di se stesso esule avversato dalla fortuna.Il sonetto si conclude con il presentimento di una sepoltura in terra straniera che il Foscolo accetta perché confortato dalla fede in una propria missione nel mondo come evocano gli ultimi versi pieni di dolore ma senza lacrime.

-Alla Musa

-In morte del fratello Giovanni