Newsgroup: it.comp.lang.c++
Titolo: intercettare qualunque terminazione anomala del programma

Salve,
ho il seguente problema:
Al momento ho un programma che elabora certe informazione e scrive i
risultati su file, che poi devo successivamente elaborare.
La dimensione di questi file sta pero' iniziando a diventare proibitiva
(superiore ai 2-3 giga) e cosi anche i tempi di analisi dati.
Ho quindi pensato di includere tutti in un unico programma e fare compiere
l'analis dei dati assieme alla loro elaborazione.
Il problema e' che puo' succcedere che il programma venga interrotto in
maniera anomala dal sistema (per eccesso di tempi di elaborazione,
creazione di file troppo grandi ecc.), richiando cosi di perdere tutte le
informazioni ottenute.
Dovrei quindi fare in modo che la scrittura su file di queste informazioni
venga sempre e comunque fatta, anche quando il programma termina in modo
anomalo.
E' quindi possibile racchiudere il main all'interno di un try{} e
intecettare qualunque eccezione, anche di sistema (importante)? 
Spero di essere stato chiaro.
Grazie
Massimo

 ha scritto nel messaggio
news:2umt8iF...@uni-berlin.de...
Il C++ consente l'uso delle eccezioni.
Nel secondo libro di Bruce Eckel, "Thinking C++ vol 2", ad esempio, c'č
proprio un capitolo dove mostra queste tecniche.
ciao.

 ciao.
Si so che ci sono le eccezioni, 
era proprio queste che volevo utilizzare ma non sono molto pratico 
perche il genere di programmazione che faccio di solito non ne richiede.
La mia domanda e' questa: avendo a che fare con cluster di computer e tempi
di calcolo molto lunghi, "l'ambiente" in cui gira il programma risulta
congenitamente instabile.
Se facessi scrivere l'output su file sarei sicuro che anche per chiusure non
previste avrei comunque i dati nel file, se invece tengo le informazione in
memoria (cosa nel complesso migliore) rischio di perderle.
Mi serve quindi un meccanismo generico che mi scriva le informazioni su file 
QUALUNQUE cosa succeda all'esecuzione del programma.
Ho provato (ma appunto non sono pratico) come segue:
int main()
        try{
             /**/
        }catch(...){scrittura_su_file();}
}
ma non funziona.
E' fondamentale che scrittua_su_file() venga richiamato SEMPRE.
(perdere 10 giorni di elaborazioni non e' proprio piacevole.... :) )
Massimo

 Massimo
La scrittura su file dovrebbe avvenire periodicamente e non tutta insieme,
rischiando appunto che un blocco di sistema vanifichi tutto il lavoro di
calcolo e scrittura in Ram.
Cerca di implementare un meccanismo che ti faccia aprire, scrivere e
chiudere il file periodicamente con risultati parziali.
Non č detto che tu riesca ad intercettare tutte le possibili eccezioni che
possono capitare.
Al massimo avrai solo perso l'ultima elaborazione prima che tu potevi
scriverla su file.
Maurus

 file QUALUNQUE cosa succeda all'esecuzione del programma.
Ciň č per principio impossibile. Se con "qualunque cosa" intendi proprio
*qualunque cosa*, allora ciň comprende anche i casi in cui l'esecuzione
deve terminare immediatamente. Di certo, il meccanismo delle eccezioni del
C++ (che č l'unico strumento standard che si puň suggerire in questa) non
consente di riprendere il controllo di un programma che ha varcato i
confini del 'comportamento indefinito' (ad es, perché ha cercato di
derefenziare un puntatore non valido).
Abbandonata la sfera del C++ standard, a seconda di quella che č la
piattaforma possono esistere strumenti o trucchi per riuscire a salvare il
salvabile anche in circostanze disastrose (come intercettare eccezioni di
sistema o gestire il SIGFAULT). Tutto dipende, in sostanza, da cosa intendi
con "qualunque cosa".
Max

 (perdere 10 giorni di elaborazioni non e' proprio piacevole.... :) )
Inserire a posteriori questo genere di meccanismo temo sara' un bagno
di sangue. Secondo me dovresti pensare a due approcci distinti: da una
parte un meccanismo di checkpoint, che salva incondizionatamente lo
stato della computazione a intervalli regolari o alla fine di
specifici passi, in modo da poter comunque riprendere dall'ultimo
checkpoint; dall'altra intercettare eccezioni e segnali di sistema ed
eventualmente tentare di effettuare un checkpoint con lo stato
corrente dell'applicazione.
Tieni presente che questo secondo intervento e' particolarmente
delicato, perche' ti troverai a dover capire se lo stato attuale della
computazione e' effettivamente salvabile in modo utile e se il sistema
ti garantisce ancora le funzionalita' minime necessarie a salvare lo
stato.
Buona fortuna!
Ciao,
Nicola

 corrente dell'applicazione.
Premesso che implementero' comunque anche la prima soluzione, dato che ho
capito (e in effetti e' sensato) che non posso proprio intercettare tutte
le possibili terminazioni anomale, leggendo un po in internet ho trovato
che e' possibile ridefinire la funzione terminate() e fargli cosi scrivere 
cio' che voglio prima dell'uscita.
Questo mi darebbe un maggiore margine di sicurezza? il terminate() viene
chiamato "quasi sempre" (a meno di crash della macchina o di terminazioni
repentine del processo da parte del sistema)? e inoltre eviterebbe di dover
andare a implementare un gestione degli errori dettagliata?
Massimo

 QUALUNQUE cosa succeda all'esecuzione del programma.
Prova questo
http://boost.org/libs/test/doc/components/execution_monitor/index.html
-- 
alef

alef wrote:

Grazie, ma preferisco non fare uso di librerie esterne,
lavorando in cluster di computer (e per giunta molto differenti tra loro)
sto cercando di evitare di dover fare uso di librerie esterne.
Massimo


Ciao,
Se non ho capito male il tuo problema, stai facendo confusione tra le
eccezioni che sono causate dal programma stesso che possono essere gestite
con il try..catch e il fatto che il sistema invii un segnale di chiusura al
programma in esecuzione per motivi dipendenti dall'ambiente in cui il
programma opera con un meccanismo tipo "kill program".
Per il secondo caso devi utilizzare la gestione del catching and handling
(cattura e gestione) dei segnali
cosě come č implementata nel tuo sistema. In POSIX, o meglio SUS3, hai
signal() e sigaction() (quest'ultima piů sicura e potente).
Buon lavoro,
fabiomdf
 
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

 andare a implementare un gestione degli errori dettagliata?
No, la funzione terminate() e' chiamata esclusivamente quando qualcosa
va storto nel meccanismo di gestione delle eccezioni. Il tuo problema
a mio avviso va affrontato invece, oltre che coi checkpoint,
attraverso un uso ragionato delle eccezioni e dell'intercettazione dei
segnali di sistema. Tra parentesi: se usi un qualche framework o
libreria, sei sicuro che non ti metta gia' a disposizione qualcosa di
utile?
Ciao,
Nicola