Fortran è più facile da ottimizzare rispetto a C per i calcoli pesanti?

StackOverflow https://stackoverflow.com/questions/146159

  •  02-07-2019
  •  | 
  •  

Domanda

Di tanto in tanto leggo che Fortran è o può essere più veloce di C per calcoli pesanti. È davvero vero? Devo ammettere che difficilmente conosco Fortran, ma il codice Fortran che ho visto finora non mostrava che il linguaggio avesse caratteristiche che C non aveva.

Se è vero, per favore dimmi perché. Per favore, non dirmi quali lingue o librerie sono buone per lo scricchiolio dei numeri, non ho intenzione di scrivere un'app o librerie per farlo, sono solo curioso.

È stato utile?

Soluzione

Le lingue hanno set di funzionalità simili. La differenza di prestazioni deriva dal fatto che Fortran afferma che l'aliasing non è consentito, a meno che non venga utilizzata un'istruzione EQUIVALENCE. Qualsiasi codice con alias non è valido Fortran, ma spetta al programmatore e non al compilatore rilevare questi errori. Pertanto i compilatori Fortran ignorano il possibile aliasing dei puntatori di memoria e consentono loro di generare codice più efficiente. Dai un'occhiata a questo piccolo esempio in C: 

void transform (float *output, float const * input, float const * matrix, int *n)
{
    int i;
    for (i=0; i<*n; i++)
    {
        float x = input[i*2+0];
        float y = input[i*2+1];
        output[i*2+0] = matrix[0] * x + matrix[1] * y;
        output[i*2+1] = matrix[2] * x + matrix[3] * y;
    }
}

Questa funzione sarebbe più lenta della controparte Fortran dopo l'ottimizzazione. Perchè così? Se si scrivono valori nell'array di output, è possibile modificare i valori di matrice. Dopotutto, i puntatori potrebbero sovrapporsi e puntare allo stesso pezzo di memoria (incluso il puntatore int !). Il compilatore C è costretto a ricaricare i quattro valori della matrice dalla memoria per tutti i calcoli.

In Fortran il compilatore può caricare una volta i valori della matrice e salvarli nei registri. Può farlo perché il compilatore Fortran presuppone che i puntatori / le matrici non si sovrappongano in memoria.

Fortunatamente, la parola chiave restring e aliasing rigoroso sono state introdotto allo standard C99 per risolvere questo problema. Al giorno d'oggi è ben supportato dalla maggior parte dei compilatori C ++. La parola chiave consente di dare al compilatore un suggerimento che il programmatore promette che un puntatore non si alias con nessun altro puntatore. Il rigoroso aliasing indica che il programmatore promette che i puntatori di diverso tipo non si sovrapporranno mai, ad esempio un double * non si sovrapporrà con un int * (con la specifica eccezione che char * e void * possono sovrapporsi a qualsiasi cosa).

Se li usi otterrai la stessa velocità da C e Fortran. Tuttavia, la possibilità di utilizzare la parola chiave restring solo con funzioni critiche per le prestazioni significa che i programmi C (e C ++) sono molto più sicuri e più facili da scrivere. Ad esempio, considera il codice Fortran non valido: CALL TRANSFORM (A (1, 30), A (2, 31), A (3, 32), 30) , che la maggior parte dei compilatori Fortran compilerà felicemente senza alcun preavviso, ma introduce un bug che viene visualizzato solo su alcuni compilatori, su alcuni componenti hardware e con alcune opzioni di ottimizzazione.

Altri suggerimenti

Sì, nel 1980; nel 2008? dipende

Quando ho iniziato a programmare professionalmente il dominio della velocità di Fortran era appena stato messo alla prova. Ricordo leggere nel Dr. Dobbs e raccontando l'articolo ai programmatori più anziani - hanno riso.

Quindi ho due opinioni su questo, teorico e pratico. In teoria Fortran oggi non ha alcun vantaggio intrinseco in C / C ++ o in qualsiasi linguaggio che consenta il codice assembly. In pratica Fortran oggi gode ancora dei vantaggi dell'eredità di una storia e cultura costruita attorno all'ottimizzazione del codice numerico.

Fino a Fortran 77 incluso, le considerazioni sulla progettazione del linguaggio avevano come obiettivo principale l'ottimizzazione. A causa dello stato della teoria e della tecnologia del compilatore, ciò spesso significava limitare le caratteristiche e le capacità al fine di offrire al compilatore la migliore possibilità di ottimizzare il codice. Una buona analogia è pensare a Fortran 77 come una macchina da corsa professionale che sacrifica le caratteristiche per la velocità. In questi giorni i compilatori sono migliorati in tutte le lingue e le funzionalità per la produttività del programmatore sono più apprezzate. Tuttavia, ci sono ancora posti in cui le persone si preoccupano principalmente della velocità nell'informatica scientifica; queste persone hanno probabilmente ereditato codice, formazione e cultura da persone che erano loro stesse programmatori Fortran.

Quando si inizia a parlare dell'ottimizzazione del codice ci sono molti problemi e il modo migliore per farsi un'idea è per nascondersi dove sono le persone il cui compito è avere un codice numerico veloce . Ma tieni presente che un codice così critico in genere è di solito una piccola parte delle linee complessive di codice e molto specializzato: molto codice Fortran è altrettanto "inefficiente". come molto altro codice in altre lingue e l'ottimizzazione non dovrebbe nemmeno essere una preoccupazione primaria di tale codice .

Un posto meraviglioso per iniziare a conoscere la storia e la cultura di Fortran è wikipedia. La voce di Wikipedia su Fortran è superba e apprezzo moltissimo coloro che si sono presi il tempo e gli sforzi per fare valore per la comunità Fortran.

(Una versione abbreviata di questa risposta sarebbe stata un commento nell'eccellente thread iniziato da Nils ma non ho il karma per farlo. In realtà, probabilmente non avrei scritto tutt'altro che per questo thread ha contenuti e condivisione di informazioni reali al contrario di guerre di fiamma e bigottismo linguistico, che è la mia esperienza principale su questo argomento. Sono stato sopraffatto e ho dovuto condividere l'amore.)

In una certa misura Fortran è stato progettato tenendo presente l'ottimizzazione del compilatore. Il linguaggio supporta operazioni di array interi in cui i compilatori possono sfruttare il parallelismo (specialmente su processori multi-core). Ad esempio,

La moltiplicazione della matrice densa è semplicemente: 

matmul(a,b)

La norma L2 di un vettore x è: 

sqrt(sum(x**2))

Inoltre dichiarazioni come FORALL , PURE & amp; Le procedure ELEMENTAL ecc. aiutano ulteriormente a ottimizzare il codice. Persino i puntatori in Fortran non sono flessibili come C per questo semplice motivo.

L'imminente standard Fortran (2008) ha co-array che consentono di scrivere facilmente codice parallelo. G95 (open source) e compilatori di CRAY lo supportano già.

Quindi sì, Fortran può essere veloce semplicemente perché i compilatori possono ottimizzarlo / parallelizzarlo meglio di C / C ++. Ma di nuovo come tutto il resto nella vita ci sono compilatori buoni e compilatori cattivi.

È divertente che molte risposte qui non conoscano le lingue. Ciò è particolarmente vero per i programmatori C / C ++ che hanno aperto e vecchio il codice FORTRAN 77 e discutono dei punti deboli.

Suppongo che il problema della velocità sia principalmente una questione tra C / C ++ e Fortran. In un codice enorme, dipende sempre dal programmatore. Ci sono alcune caratteristiche del linguaggio che Fortran supera e alcune caratteristiche che C fa. Quindi, nel 2011, nessuno può davvero dire quale è più veloce.

Per quanto riguarda la lingua stessa, Fortran al giorno d'oggi supporta le funzionalità Full OOP ed è completamente compatibile con le versioni precedenti. Ho usato a fondo il Fortran 2003 e direi che è stato delizioso usarlo. Per alcuni aspetti, Fortran 2003 è ancora dietro C ++ ma diamo un'occhiata all'utilizzo. Fortran viene utilizzato principalmente per il calcolo numerico e nessuno utilizza fantasiose funzionalità OOP in C ++ per motivi di velocità. Nel calcolo ad alte prestazioni, C ++ non ha quasi nessun posto dove andare (dai un'occhiata allo standard MPI e vedrai che C ++ è stato deprecato!).

Al giorno d'oggi, puoi semplicemente programmare in linguaggio misto con Fortran e C / C ++. Ci sono persino interfacce per GTK + in Fortran. Ci sono compilatori gratuiti (gfortran, g95) e molti altri eccellenti commerciali.

Esistono diversi motivi per cui Fortran potrebbe essere più veloce. Tuttavia, la quantità che contano è così insignificante o può essere aggirata comunque, che non dovrebbe importare. Il motivo principale per utilizzare Fortran al giorno d'oggi è il mantenimento o l'estensione di applicazioni legacy.

  • Parole chiave PURE ed ELEMENTAL sulle funzioni. Queste sono funzioni che non hanno effetti collaterali. Ciò consente l'ottimizzazione in alcuni casi in cui il compilatore sa che la stessa funzione verrà chiamata con gli stessi valori. Nota: GCC implementa "puro" come estensione della lingua. Anche altri compilatori possono. Anche l'analisi tra moduli può eseguire questa ottimizzazione, ma è difficile.

  • set standard di funzioni che si occupano di array, non di singoli elementi. Roba come sin (), log (), sqrt () accetta array invece di scalari. Ciò semplifica l'ottimizzazione della routine. La vettorializzazione automatica offre gli stessi vantaggi nella maggior parte dei casi se queste funzioni sono incorporate o incorporate

  • Tipo complesso incorporato. In teoria ciò potrebbe consentire al compilatore di riordinare o eliminare determinate istruzioni in alcuni casi, ma probabilmente vedresti lo stesso vantaggio con la struttura {double re, im; }; idioma usato in C. Rende per uno sviluppo più veloce anche se gli operatori lavorano su tipi complessi in fortran.

Penso che il punto chiave a favore di Fortran sia che è un linguaggio leggermente più adatto per esprimere la matematica basata su vettori e array. Il problema di analisi del puntatore sopra indicato è in pratica reale, poiché il codice portatile non può davvero supporre che si possa dire qualcosa a un compilatore. Vi è SEMPRE un vantaggio nell'espressione computaitons in un modo più vicino a come appare il dominio. C non ha affatto array, se guardi da vicino, solo qualcosa che si comporta in questo modo. Fortran ha veri e propri arrawys. Ciò rende più semplice la compilazione per determinati tipi di algoritmi, in particolare per macchine parallele.

Nel profondo di cose come il sistema di runtime e le convenzioni di chiamata, C e il moderno Fortran sono sufficientemente simili che è difficile vedere cosa farebbe la differenza. Si noti che C qui è davvero C: C ++ è un problema totalmente diverso con caratteristiche prestazionali molto diverse.

Non esiste una lingua più veloce di un'altra, quindi la risposta corretta è no .

Quello che devi veramente chiedere è "il codice è compilato con il compilatore X Fortran più velocemente del codice equivalente compilato con il compilatore C Y?" La risposta a questa domanda ovviamente dipende da quali due compilatori scegli.

Un'altra domanda che ci si potrebbe porre sarebbe sulla falsariga di "Dato lo stesso sforzo messo nell'ottimizzazione nei loro compilatori, quale compilatore produrrebbe un codice più veloce?" La risposta a questo sarebbe infatti Fortran . I compilatori Fortran hanno i vantaggi di Certian:

  • Fortran dovette competere con Assembly nel giorno in cui alcuni giurarono di non usare mai compilatori, quindi fu progettato per la velocità. C è stato progettato per essere flessibile.
  • La nicchia di Fortran è stata il numero di scricchiolii. In questo codice di dominio non è mai abbastanza veloce. Quindi c'è sempre stata molta pressione per mantenere efficiente la lingua.
  • La maggior parte della ricerca sull'ottimizzazione del compilatore viene effettuata da persone interessate ad accelerare il codice di scricchiolio dei numeri Fortran, quindi l'ottimizzazione del codice Fortran è un problema molto più noto rispetto all'ottimizzazione di qualsiasi altro linguaggio compilato, e le nuove innovazioni compaiono prima nei compilatori Fortran.
  • Biggie : C incoraggia molto più utilizzo del puntatore rispetto a Fortran. Ciò aumenta drasticamente la portata potenziale di qualsiasi elemento di dati in un programma C, il che li rende molto più difficili da ottimizzare. Nota che Ada è anche molto meglio di C in questo regno, ed è un linguaggio OO molto più moderno rispetto al comune Fortran77. Se vuoi un linguaggio OO in grado di generare codice più veloce di C, questa è un'opzione per te.
  • A causa della sua nicchia di numeri, i clienti dei compilatori Fortran tendono a preoccuparsi di più dell'ottimizzazione rispetto ai clienti dei compilatori C.

Tuttavia, non c'è niente che impedisce a qualcuno di impegnarsi moltissimo nell'ottimizzazione del proprio compilatore C e di fargli generare codice migliore del compilatore Fortran della propria piattaforma. In effetti, le maggiori vendite generate dai compilatori C rendono questo scenario abbastanza fattibile

C'è un altro elemento in cui Fortran è diverso da C - e potenzialmente più veloce. Fortran ha regole di ottimizzazione migliori di C. In Fortran, l'ordine di valutazione di un'espressione non è definito, il che consente al compilatore di ottimizzarlo - se si vuole forzare un certo ordine, si devono usare le parentesi. In C l'ordine è molto più rigoroso, ma con " -fast " opzioni, sono più rilassate e " (...) " sono anche ignorati. Penso che Fortran abbia un modo che sta bene nel mezzo. (Bene, IEEE rende la vita più difficile poiché alcune modifiche dell'ordine di valutazione richiedono che non si verifichino overflow, che devono essere ignorati o ostacolano la valutazione).

Un'altra area di regole più intelligenti sono i numeri complessi. Non solo che ci sono voluti fino a C 99 che C li aveva, anche le regole che li governano sono migliori a Fortran; poiché la libreria Fortran di gfortran è parzialmente scritta in C ma implementa la semantica Fortran, GCC ha ottenuto l'opzione (che può essere utilizzata anche con i programmi "normali" C):

  

-fcx-FORTRAN-rules   La moltiplicazione e la divisione complesse seguono le regole di Fortran. La riduzione della portata viene effettuata come parte di una divisione complessa, ma non è possibile verificare se il risultato di una moltiplicazione o divisione complessa sia "NaN + I * NaN", nel tentativo di salvare la situazione in quel caso.

Le regole di alias sopra menzionate sono un altro vantaggio e anche - almeno in linea di principio - le operazioni dell'intero array, che se prese correttamente in considerazione dall'ottimizzatore del compilatore, possono portare codice più veloce. Al contrario, alcune operazioni richiedono più tempo, ad es. se si fa un'assegnazione a un array allocabile, ci sono molti controlli necessari (riallocare? [funzionalità Fortran 2003], ha i passi da array, ecc.), che rendono l'operazione semplice più complessa dietro le quinte - e quindi più lenta, ma rende la lingua più potente. D'altra parte, le operazioni di array con limiti e passi flessibili facilitano la scrittura del codice e il compilatore di solito ottimizza il codice meglio di un utente.

In totale, penso che sia C che Fortran siano altrettanto veloci; la scelta dovrebbe essere più di quale linguaggio piace di più o se usare le operazioni dell'intero array di Fortran e la sua migliore portabilità siano più utili - oppure l'interfaccia migliore con le librerie dell'interfaccia utente grafica e di sistema in C.

Non c'è nulla nelle lingue Fortran e C che rendono l'una più veloce dell'altra per scopi specifici. Ci sono cose su compilatori specifici per ognuna di queste lingue che rendono alcuni favorevoli ad alcuni compiti più di altri.

Per molti anni sono esistiti compilatori Fortran che potevano fare magie nere alle tue routine numeriche, rendendo molti calcoli importanti follemente veloci. Anche i compilatori C contemporanei non potevano farlo. Di conseguenza, un certo numero di grandi librerie di codice è cresciuto in Fortran. Se vuoi usare queste librerie ben collaudate, mature e meravigliose, fai fuori il compilatore Fortran.

Le mie osservazioni informali dimostrano che oggigiorno le persone codificano le loro pesanti cose di calcolo in qualsiasi vecchia lingua e se impiegano un po 'di tempo trovano tempo su un cluster di calcolo economico. La Legge di Moore ci prende in giro tutti.

Confronto la velocità di Fortran, C e C ++ con il classico benchmark Levine-Callahan-Dongarra di Netlib. La versione in più lingue, con OpenMP, è http://sites.google.com/site/tprincesite/levine-callahan -dongarra-vettori La C è più brutta, poiché è iniziata con la traduzione automatica, oltre all'inserimento di restringimenti e pragmi per alcuni compilatori. C ++ è solo C con modelli STL ove applicabile. A mio avviso, la STL è un miscuglio se migliora la manutenibilità.

Esiste solo un minimo esercizio di allineamento delle funzioni automatiche per vedere fino a che punto migliora l'ottimizzazione, poiché gli esempi si basano sulla pratica tradizionale di Fortran in cui si fa poco affidamento sull'in-lining.

Il compilatore C / C ++ che ha di gran lunga l'uso più diffuso manca di auto-vettorizzazione, su cui questi benchmark fanno molto affidamento.

Per quanto riguarda il post che è arrivato poco prima: ci sono un paio di esempi in cui le parentesi sono usate in Fortran per dettare l'ordine di valutazione più veloce o più accurato. I compilatori C noti non hanno opzioni per osservare le parentesi senza disabilitare le ottimizzazioni più importanti.

Stavo facendo un po 'di matematica approfondita con FORTRAN e C per un paio di anni. Dalla mia esperienza posso dire che a volte FORTRAN è davvero migliore di C ma non per la sua velocità (si può fare in modo che C funzioni più velocemente di FORTRAN usando lo stile di codifica appropriato) ma piuttosto a causa di librerie molto ottimizzate come LAPACK, e per via di grande parallelizzazione. Secondo me, FORTRAN è davvero scomodo con cui lavorare, e i suoi vantaggi non sono abbastanza buoni per annullare questo inconveniente, quindi ora sto usando C + GSL per fare calcoli.

Sono un programmatore hobbista e sono "medio". in entrambe le lingue. Trovo più facile scrivere codice Fortran veloce rispetto al codice C (o C ++). Sia Fortran che C sono "storici" le lingue (oggi standard), sono ampiamente utilizzate e hanno un compilatore gratuito e commerciale ben supportato.

Non so se sia un fatto storico, ma Fortran ha la sensazione di essere costruito per essere parallelo / distribuito / vettorializzato / qualunque-molti-core-ized. E oggi è praticamente la "metrica standard" quando parliamo di velocità: " ridimensiona? "

Per il puro scricchiolio della CPU adoro Fortran. Per tutto ciò che riguarda IO, trovo più facile lavorare con C. (è comunque difficile in entrambi i casi).

Ora ovviamente, per il codice parallelo di matematica intensiva, probabilmente vuoi usare la tua GPU. Sia C che Fortran hanno molte interfacce CUDA / OpenCL più o meno ben integrate (e ora OpenACC).

La mia risposta moderatamente obiettiva è: se conosci entrambe le lingue ugualmente bene / male allora penso che Fortran sia più veloce perché trovo più facile scrivere codice parallelo / distribuito in Fortran di C. (una volta capito che puoi scrivere " formato libero " fortran e non solo codice F77 rigoroso)

Ecco una seconda risposta per coloro che vogliono sottovalutarmi perché non gradiscono la prima risposta: entrambe le lingue hanno le funzionalità richieste per scrivere codice ad alte prestazioni. Quindi dipende dall'algoritmo che stai implementando (intensivo della cpu? Io intensivo? Intensivo della memoria?), L'hardware (single cpu? Multi-core? Distribuisci supercomputer? GPGPU? FPGA?), La tua abilità e, in definitiva, il compilatore stesso. Sia C che Fortran hanno un compilatore fantastico. (Sono seriamente stupito da quanto siano avanzati i compilatori Fortran ma anche i compilatori C).

PS: sono felice che tu abbia escluso specificamente le librerie perché ho molte cose brutte da dire sulle librerie della GUI di Fortran. :)

Non ho sentito che Fortan sia significativamente più veloce di C, ma potrebbe essere immaginabile che in alcuni casi sarebbe più veloce. E la chiave non sta nelle caratteristiche linguistiche presenti, ma in quelle (di solito) assenti.

Un esempio sono i puntatori C. I puntatori C sono usati praticamente dappertutto, ma il problema con i puntatori è che il compilatore di solito non può dire se stanno puntando a parti diverse dello stesso array.

Ad esempio se hai scritto una routine strcpy simile a questa: 

strcpy(char *d, const char* s)
{
  while(*d++ = *s++);
}

Il compilatore deve funzionare supponendo che d e s possano essere array sovrapposti. Quindi non può eseguire un'ottimizzazione che produrrebbe risultati diversi quando gli array si sovrappongono. Come prevedibile, ciò limita notevolmente il tipo di ottimizzazioni che è possibile eseguire.

[Devo notare che C99 ha un "limite" " parola chiave che indica esplicitamente ai compilatori che i puntatori non si sovrappongono. Si noti inoltre che anche il Fortran ha puntatori, con semantica diversa da quelli di C, ma i puntatori non sono onnipresenti come in C.]

Ma tornando al problema C vs. Fortran, è concepibile che un compilatore Fortran sia in grado di eseguire alcune ottimizzazioni che potrebbero non essere possibili per un programma C (scritto in modo semplice). Quindi non sarei troppo sorpreso dall'affermazione. Tuttavia, mi aspetto che la differenza di prestazioni non sia così grande. [~ 5-10%]

Qualsiasi differenza di velocità tra Fortran e C sarà più una funzione delle ottimizzazioni del compilatore e della libreria matematica sottostante utilizzata dal compilatore specifico. Non c'è nulla di intrinseco in Fortran che lo renderebbe più veloce di C.

Ad ogni modo, un buon programmatore può scrivere Fortran in qualsiasi lingua.

Rapido e semplice: Entrambi sono ugualmente veloci, ma Fortran è più semplice. Ciò che è veramente più veloce alla fine dipende dall'algoritmo, ma non c'è comunque una differenza di velocità considerevole. Questo è ciò che ho imparato in un seminario Fortran presso il centro di calcolo ad alte prestazioni Stuttgard, Germania nel 2015. Lavoro sia con Fortran che con C e condivido questa opinione.

Spiegazione:

C è stato progettato per scrivere sistemi operativi. Quindi ha più libertà del necessario per scrivere codice ad alte prestazioni. In generale questo non è un problema, ma se non si programma con attenzione, si può facilmente rallentare il codice.

Fortran è stato progettato per la programmazione scientifica. Per questo motivo, supporta la scrittura della sintassi del codice veloce, poiché questo è lo scopo principale di Fortran. Contrariamente all'opinione pubblica, Fortran non è un linguaggio di programmazione obsoleto. Il suo ultimo standard è il 2010 e i nuovi compilatori sono pubblicati su base regolare, poiché la maggior parte del codice ad alte prestazioni è scritto in Fortran. Fortran supporta inoltre le funzionalità moderne come direttive del compilatore (in pragmi C).

Esempio: Vogliamo dare una grande struttura come argomento di input a una funzione (fortran: subroutine). All'interno della funzione l'argomento non è modificato.

C supporta entrambi, chiama per riferimento e chiama per valore, che è una funzione utile. Nel nostro caso, il programmatore potrebbe accidentalmente utilizzare la chiamata in base al valore. Questo rallenta notevolmente le cose, poiché la struttura deve essere prima copiata nella memoria.

Fortran funziona solo con la chiamata per riferimento, il che obbliga il programmatore a copiare la struttura a mano, se vuole davvero un'operazione di chiamata in base al valore. Nel nostro caso fortran sarà automaticamente veloce quanto la versione C con chiamata per riferimento.

Generalmente FORTRAN è più lento di C. C può usare puntatori di livello hardware che consentono al programmatore di ottimizzare a mano. FORTRAN (nella maggior parte dei casi) non ha accesso agli hack di memoria dell'hardware. (VAX FORTRAN è un'altra storia.) Ho usato FORTRAN dentro e fuori dagli anni '70. (Davvero).

Tuttavia, a partire dagli anni '90, FORTRAN si è evoluto per includere costrutti linguistici specifici che possono essere ottimizzati in algoritmi intrinsecamente paralleli che può davvero urlare su un processore multi-core. Ad esempio, la vettorializzazione automatica consente a più processori di gestire contemporaneamente ogni elemento in un vettore di dati. 16 processori - 16 elementi vettoriali - l'elaborazione richiede 1/16 del tempo.

In C, devi gestire i tuoi thread e progettare con cura l'algoritmo per l'elaborazione multipla, quindi utilizzare una serie di chiamate API per assicurarti che il parallelismo avvenga correttamente.

In FORTRAN, devi solo progettare attentamente il tuo algoritmo per l'elaborazione multipla. Il compilatore e il runtime possono gestire il resto per te.

Puoi leggere un po 'di High Performance Fortran , ma trovi molti link morti. Stai meglio leggendo sulla programmazione parallela (come OpenMP.org ) e come FORTRAN lo supporta.

Il codice più veloce non è veramente all'altezza della lingua, è il compilatore in modo da poter vedere il compilatore ms-vb " " che genera un codice oggetto gonfio, più lento e ridondante che è collegato all'interno di un ".exe", ma powerBasic genera un codice troppo migliore. Il codice oggetto creato dai compilatori C e C ++ viene generato in alcune fasi (almeno 2) ma, per progettazione, la maggior parte dei compilatori Fortran ha almeno 5 fasi, tra cui ottimizzazioni di alto livello, quindi, per progettazione, Fortran sarà sempre in grado di generare codice altamente ottimizzato. Quindi alla fine il compilatore non è la lingua che dovresti chiedere, il miglior compilatore che conosco è il compilatore Intel Fortran perché puoi ottenerlo su LINUX e Windows e puoi usare VS come IDE, se stai cercando un compilatore tigh economico che puoi sempre inoltrare su OpenWatcom.

Maggiori informazioni su questo: http://ed-thelen.org/1401Project/1401-IBM -Systems-Journal-FORTRAN.html

Fortran ha routine di I / O migliori, ad es. la funzione implicita do offre flessibilità che la libreria standard di C non può eguagliare.

Il compilatore Fortran gestisce direttamente i più complessi sintassi coinvolta, e come tale sintassi non può essere facilmente ridotta all'argomento che passa forma, C non può implementarlo in modo efficiente.

Utilizzando standard moderni e compilatore, no!

Alcune delle persone qui hanno suggerito che FORTRAN è più veloce perché il compilatore non deve preoccuparsi dell'aliasing (e quindi può fare più ipotesi durante l'ottimizzazione). Tuttavia, questo è stato affrontato in C dallo standard C99 (credo) con l'inclusione della parola chiave restringente. Il che sostanzialmente dice al compilatore, che all'interno di un ambito scope, il puntatore non è alias. Inoltre, C consente una corretta aritmetica del puntatore, in cui cose come l'aliasing possono essere molto utili in termini di prestazioni e allocazione delle risorse. Anche se penso che la versione più recente di FORTRAN consenta l'uso di "corretto" puntatori.

Per le implementazioni moderne, C in generale supera FORTRAN (anche se è molto veloce).

http://benchmarksgame.alioth.debian.org/u64q/fortran.html

EDIT:

Una giusta critica al riguardo sembra essere che il benchmarking possa essere distorto. Ecco un'altra fonte (relativa a C) che mette il risultato in più contesto:

http://julialang.org/benchmarks/

Puoi vedere che C in genere supera Fortran nella maggior parte dei casi (vedi ancora critiche che si applicano anche qui); come altri hanno affermato, il benchmarking è una scienza inesatta che può essere facilmente caricata per favorire una lingua rispetto ad altre. Ma mette in contesto il modo in cui Fortran e C hanno prestazioni simili.

Fortran può gestire array, in particolare array multidimensionali, in modo molto conveniente. Affettare elementi di array multidimensionali in Fortran può essere molto più semplice di quello in C / C ++. C ++ ora ha librerie in grado di fare il lavoro, come Boost o Eigen, ma lo sono dopo tutte le librerie esterne. In Fortran queste funzioni sono intrinseche.

Il fatto che Fortran sia più veloce o più conveniente per lo sviluppo dipende principalmente dal lavoro che devi completare. Come persona di calcolo scientifico per la geofisica, ho fatto la maggior parte del calcolo in Fortran (intendo il moderno Fortran, > = F90).

Questo è più che un po 'soggettivo, perché entra nella qualità dei compilatori e più di ogni altra cosa. Tuttavia, per rispondere più direttamente alla tua domanda, parlando dal punto di vista della lingua / del compilatore non c'è nulla su Fortran su C che lo renderà intrinsecamente più veloce o migliore di C. Se stai eseguendo pesanti operazioni matematiche, scenderà al qualità del compilatore, abilità del programmatore in ogni lingua e intrinseche librerie di supporto matematico che supportano tali operazioni per determinare in definitiva quale sarà più veloce per una data implementazione.

EDIT: altre persone come @Nils hanno sollevato il punto positivo sulla differenza nell'uso dei puntatori in C e sulla possibilità di alias che forse rallenta le implementazioni più ingenue in C. Tuttavia, ci sono modi per affrontare quello in C99, tramite flag di ottimizzazione del compilatore e / o in come la C è effettivamente scritta. Questo è ben coperto nella risposta di @Nils e nei successivi commenti che seguono sulla sua risposta.

La maggior parte dei post presenta già argomenti interessanti, quindi aggiungerò i proverbiali 2 centesimi a un aspetto diverso.

Essere fortran più veloce o più lento in termini di potenza di elaborazione alla fine può avere la sua importanza, ma se ci vuole 5 volte più tempo per sviluppare qualcosa in Fortran perché:

  • manca una buona libreria per compiti diversi dal puro scricchiolio dei numeri
  • manca uno strumento decente per la documentazione e il testing delle unità
  • è un linguaggio con espressività molto bassa, che sale alle stelle il numero di righe di codice.
  • ha una pessima gestione delle stringhe
  • ha una quantità insana di problemi tra diversi compilatori e architetture che ti fanno impazzire.
  • ha una strategia I / O molto scadente (LEGGI / SCRIVI di file sequenziali. Sì, esistono file ad accesso casuale ma li hai mai visti usati?)
  • non incoraggia buone pratiche di sviluppo, la modularizzazione.
  • mancanza effettiva di un compilatore open source completamente standard e pienamente conforme (sia gfortran che g95 non supportano tutto)
  • interoperabilità molto scarsa con C (mangling: un carattere di sottolineatura, due caratteri di sottolineatura, nessun carattere di sottolineatura, in genere un carattere di sottolineatura ma due se c'è un altro carattere di sottolineatura.

Quindi il problema è irrilevante. Se qualcosa è lento, il più delle volte non è possibile migliorarlo oltre un determinato limite. Se vuoi qualcosa di più veloce, modifica l'algoritmo. Alla fine, il tempo del computer è economico. Il tempo umano non lo è. Valorizza la scelta che riduce il tempo umano. Se aumenta il tempo del computer, è comunque conveniente.

Fortran tradizionalmente non imposta opzioni come -fp: strict (che ifort richiede per abilitare alcune delle funzionalità in USE IEEE_arithmetic, una parte dello standard f2003). Anche Intel C ++ non imposta -fp: rigoroso come predefinito, ma questo è necessario per la gestione di ERRNO, ad esempio, e altri compilatori C ++ non rendono conveniente disattivare ERRNO o ottenere ottimizzazioni come la riduzione del simd. gcc e g ++ mi hanno richiesto di impostare Makefile per evitare di usare la pericolosa combinazione -O3 -ffast-math -fopenmp -march = native. Oltre a questi problemi, questa domanda sulle prestazioni relative diventa più pignola e dipendente dalle regole locali sulla scelta dei compilatori e delle opzioni.

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top