Newsgroup: it.comp.os.linux.iniziare
Titolo: gnu compiler ottimizzare preservando doppia precisione

Scusate se chiedo qui, non è troppo attinente all'argomento
sistemi operativi... ma siccome ho già chiesto prima nel topic
"come si ferma un programma a mano" provo a chiedere qui.
 
Allora ho questo sorgente fortran che posso compilare con
 
gfortran -o programma.bin programma.f
 
È un programma scritto praticamente in fortran 77
fa calcoli su variabili in doppia precisione...
Fa parecchi calcoli e li ripete per infinite
volte teoricamente trovando un risultato migliore
al giro successivo.
 
Per cui è importante che giri più rapidamente possibile.
Allo stesso tempo visto che paarliamo di grandezze fisiche
ecc, la precisione nei calcoli è un must e deve essere
preservata la doppia precisione.
 
Ho letto e constatato provando che l'eseguibile è parecchio
più rapido se viene ottenuto compilando con qualche opzione
di ottimizzazione:
 
gfortran -Ofast -march=native -fno-gcse -o programma.bin programma.f
 
Però in questo modo il risultato che dovrebbe cambiare ad
ogni reiterazione diventando sempre un po' più piccolo, in
realtà non varia più. O almeno la variazione non viene
visualizzata.
 
Infatti mentre il programma gira, stampa a video questo valore
che è appunto indicativo della bontà del risultato. Una cosa del
tipo:
---
 valore=   4.8868482388357531E-002         403
 valore=   4.8868482332274164E-002         404
 valore=   4.8868482332218410E-002         405
 valore=   4.8868482323832681E-002         406
 valore=   4.8868481574640708E-002         407
 valore=   4.8868481547551954E-002         408
 valore=   4.8868481466771627E-002         409
---
 
Insomma è un numero in doppia precisione che va in calando
ad ogni giro.
L'esempio sopra è quanto vedo a video metre sta girando l'eseguiile
compilato senza le ottimizzazioni.
 
Se compilo aggiungendo le opzioni di -Ofast ecc riportate sopra
ed eseguo il binario dandogli lo stesso input di prima ottengo
dei risultati completamente diversi:
---
 valore=   4.8868888502700901E-002         403
 valore=   4.8868888502700901E-002         404
 valore=   4.8868888502700901E-002         405
 valore=   4.8868888502700901E-002         406
 valore=   4.8868888502700901E-002         407
 valore=   4.8868888502700901E-002         408
 valore=   4.8868888502700901E-002         409
---
 
Dalla sua questa seconda esecuzione presenta una velocità
evidentemente maggiore. Ma non è accettabile che non vi
siano differenze tra i valori di reiteraioni disverse.
 
Anche perchè se fosse davvero vero quello, il programma
ha un'istruzione precisa che gli impone di fermarsi, in
pratica significherebbe che il nostro "valore" ha raggiunto
il minimo possibile.
 
C'è modo di compilare con qualche opzione tale da ottenere un
eseguibile quanto più rapido ma al contempo che dia risultati
in doppia precisione?


RTFM
man gfrotran
 
devi guardare nel man del compilatore cosa fanno le opzioni che usi, se ce ne sono altre migliori, ecc.
 
cmq prova a togliere tutte le opzioni e mettere -O2, e vedi cosa succede.
 
Ciao Jack

 vedi cosa succede.
 
Grazie, cercherò informazioni a partire dal manuale
del compilatore.
Ho provato mettendo solo -O2.
Ma ecco che salta fuori il problema spiegato sopra:
i numeri che appaiono a schermo restano sempre tutti
identici.
 
Leggevo della possibilità di parallelzzare le operazioni
in modo da sfruttare meglio più core. Ma da quel che vedo
il mio programma presenta caratteristiche che forse non
permettono questa possibilità. e andrebbe rimaneggiato
un po'.
Non è una possibilità da escludere...
 
Ad ogni modo... Grazie ancora!  :)

Il giorno venerdì 15 gennaio 2016 16:02:44 UTC+1, Joe ha scritto:

non conosco gfrotran, devi vedere nel man cosa fa il -O2, in genere raggruppa diverse ottimizzazioni, probailmente ce n'e' una che crea problemi.
 
Ciao Jack