Fortran est-il plus facile à optimiser que C pour les calculs lourds?

De temps en temps, je lis que Fortran est ou peut être plus rapide que C pour les calculs lourds. Est-ce vraiment vrai? Je dois admettre que je connais à peine Fortran, mais le code Fortran que j’ai vu jusqu’à présent n’a pas montré que le langage possède des fonctionnalités que C n’a pas.

Si c’est vrai, s’il vous plaît dites-moi pourquoi. S’il vous plaît, ne me dites pas quelles langues ou librairies sont bonnes pour les calculs, je n’ai pas l’intention d’écrire une application ou une librairie pour faire cela, je suis juste curieux.

Les langues ont des ensembles de fonctionnalités similaires. La différence de performance provient du fait que Fortran dit que l’aliasing n’est pas autorisé, à moins d’utiliser une déclaration EQUIVALENCE. Tout code comportant un aliasing n’est pas valide Fortran, mais il appartient au programmeur et non au compilateur de détecter ces erreurs. Ainsi, les compilateurs Fortran ignorent les alias possibles des pointeurs de mémoire et leur permettent de générer un code plus efficace. Jetez un oeil à ce petit exemple en C:

void transform (float *output, float const * input, float const * masortingx, 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; } } 

Cette fonction serait plus lente que l’homologue Fortran après l’optimisation. Pourquoi donc Si vous écrivez des valeurs dans le tableau de sortie, vous pouvez modifier les valeurs de la masortingce. Après tout, les pointeurs peuvent se chevaucher et pointer vers le même morceau de mémoire (y compris le pointeur int !). Le compilateur C est obligé de recharger les quatre valeurs de masortingce de la mémoire pour tous les calculs.

Dans Fortran, le compilateur peut charger les valeurs de la masortingce une fois et les stocker dans des registres. Cela peut se faire parce que le compilateur Fortran suppose que les pointeurs / tableaux ne se chevauchent pas dans la mémoire.

Heureusement, le mot-clé ressortingct et l'aliasing ssortingct ont été introduits dans le standard C99 pour résoudre ce problème. Il est bien supporté dans la plupart des compilateurs C ++ de nos jours. Le mot-clé vous permet de donner au compilateur un indice que le programmeur promet qu’un pointeur n’a pas d’alias avec un autre pointeur. Le ssortingct aliasing signifie que le programmeur promet que les pointeurs de type différent ne se chevaucheront jamais, par exemple un double* ne chevauchera pas avec un int* (à la seule exception que char* et void* peuvent chevaucher n'importe quoi).

Si vous les utilisez, vous obtiendrez la même vitesse de C et Fortran. Cependant, la possibilité d'utiliser le mot-clé ressortingct uniquement avec les fonctions de performances critiques signifie que les programmes C (et C ++) sont beaucoup plus sûrs et plus faciles à écrire. Par exemple, considérons le code Fortran invalide: CALL TRANSFORM(A(1, 30), A(2, 31), A(3, 32), 30) , que la plupart des compilateurs Fortran comstackront sans avertissement mais introduiront un bogue cela ne s'affiche que sur certains compilateurs, sur certains matériels et avec certaines options d'optimisation.

Oui, en 1980; En 2008? dépend

Lorsque j’ai commencé à programmer professionnellement, la domination de la vitesse de Fortran était simplement mise au défi. Je me souviens avoir lu à ce sujet dans Dr. Dobbs et raconter l’article aux programmeurs plus âgés – ils ont ri.

J’ai donc deux points de vue à ce sujet, théoriques et pratiques. En théorie, Fortran n’a aucun avantage insortingnsèque pour C / C ++ ou même pour tout langage autorisant le code d’assemblage. En pratique, Fortran bénéficie encore aujourd’hui des avantages d’une histoire et d’une culture construites autour de l’optimisation du code numérique.

Jusqu’à et incluant Fortran 77, l’optimisation constituait l’objective principal de la conception de la langue. En raison de l’état de la théorie et de la technologie du compilateur, cela impliquait souvent de limiter les fonctionnalités et les capacités afin de permettre au compilateur d’optimiser le code. Une bonne analogie est de penser à Fortran 77 comme une voiture de course professionnelle qui sacrifie les caractéristiques pour la vitesse. De nos jours, les compilateurs se sont améliorés dans toutes les langues et les fonctionnalités pour la productivité des programmeurs sont plus appréciées. Cependant, il y a encore des endroits où les gens sont principalement préoccupés par la vitesse dans le calcul scientifique; Ces personnes ont probablement hérité du code, de la formation et de la culture de personnes qui étaient elles-mêmes des programmeurs Fortran.

Quand on commence à parler de l’optimisation du code, il ya beaucoup de problèmes et la meilleure façon d’en avoir une idée est de savoir où se trouvent les personnes qui doivent avoir un code numérique rapide . Mais gardez à l’esprit qu’un tel code sensible est généralement une petite fraction des lignes de code globales et très spécialisé: beaucoup de code Fortran est tout aussi “inefficace” qu’un grand nombre d’autres codes dans d’autres langages et que l’ optimisation ne devrait même pas être une préoccupation principale de ce code .

Wikipedia est un endroit merveilleux pour apprendre l’histoire et la culture de Fortran. L’entrée de Fortran Wikipedia est superbe et j’apprécie énormément ceux qui ont pris le temps et les efforts nécessaires pour la rendre intéressante pour la communauté Fortran.

(Une version raccourcie de cette réponse aurait été un commentaire dans l’excellent sujet lancé par Nils mais je n’ai pas le karma pour le faire. En fait, je n’aurais probablement rien écrit du tout, mais pour cela ce sujet a été écrit. contenu de l’information et partage par opposition à la guerre des flammes et à la bigoterie linguistique, qui est ma principale expérience avec ce sujet. J’étais submergé et je devais partager l’amour.)

Dans une certaine mesure, Fortran a été conçu pour conserver l’optimisation du compilateur. Le langage prend en charge des opérations de tableau complètes où les compilateurs peuvent exploiter le parallélisme (en particulier sur les processeurs multicœurs). Par exemple,

La multiplication par masortingce dense est simplement:

 matmul(a,b) 

La norme L2 d’un vecteur x est:

 sqrt(sum(x**2)) 

De plus, des instructions telles que les FORALL , PURE & ELEMENTAL , etc., consortingbuent à optimiser le code. Même les pointeurs dans Fortran ne sont pas aussi flexibles que C pour cette raison simple.

Le prochain standard Fortran (2008) comporte des co-tableaux qui vous permettent d’écrire facilement du code parallèle. G95 (open source) et les compilateurs de CRAY le supportent déjà.

Donc, oui, Fortran peut être rapide simplement parce que les compilateurs peuvent l’optimiser / le paralléliser mieux que C / C ++. Mais encore une fois, comme dans toute la vie, il y a de bons compilateurs et de mauvais compilateurs.

Il est amusant de constater que beaucoup de réponses proviennent de la méconnaissance des langues. Cela est particulièrement vrai pour les programmeurs C / C ++ qui ont ouvert et utilisé un ancien code FORTRAN 77 pour discuter des faiblesses.

Je suppose que le problème de la vitesse est principalement une question entre C / C ++ et Fortran. Dans un code énorme, cela dépend toujours du programmeur. Il existe certaines fonctionnalités du langage que Fortran surpasse et certaines fonctionnalités de C. Donc, en 2011, personne ne peut vraiment dire laquelle est la plus rapide.

À propos de la langue elle-même, Fortran prend désormais en charge les fonctionnalités Full OOP et est entièrement rétro-compatible. J’ai utilisé le Fortran 2003 à fond et je dirais que c’était tout simplement agréable de l’utiliser. Dans certains aspects, Fortran 2003 est toujours en retard sur C ++, mais regardons l’utilisation. Fortran est principalement utilisé pour le calcul numérique, et personne n’utilise les fonctionnalités de C ++ OOP sophistiquées pour des raisons de rapidité. En informatique haute performance, C ++ n’a pratiquement pas de place (jetez un oeil à la norme MPI et vous verrez que C ++ est devenu obsolète!).

De nos jours, vous pouvez simplement faire de la programmation en langage mixte avec Fortran et C / C ++. Il existe même des interfaces pour GTK + dans Fortran. Il y a des compilateurs gratuits (gfortran, g95) et de nombreux excellents commerciaux.

Il y a plusieurs raisons pour lesquelles Fortran pourrait être plus rapide. Cependant, la quantité qu’ils importent est si peu importante ou peut être évitée de toute façon, que cela ne devrait pas avoir d’importance. La principale raison d’utiliser Fortran de nos jours est de conserver ou d’étendre les applications existantes.

  • Mots-clés PURE et ELEMENTAL sur les fonctions. Ce sont des fonctions sans effets secondaires. Cela permet des optimisations dans certains cas où le compilateur sait que la même fonction sera appelée avec les mêmes valeurs. Remarque: GCC implémente “pure” comme extension du langage. D’autres compilateurs peuvent aussi. L’parsing inter-modules peut également effectuer cette optimisation mais c’est difficile.

  • ensemble standard de fonctions qui traitent des tableaux, pas des éléments individuels. Des choses comme sin (), log (), sqrt () prennent des tableaux au lieu de scalaires. Cela facilite l’optimisation de la routine. La vectorisation automatique offre les mêmes avantages dans la plupart des cas si ces fonctions sont intégrées ou intégrées

  • Type complexe intégré. En théorie, cela pourrait permettre au compilateur de réorganiser ou d’éliminer certaines instructions dans certains cas, mais vous verriez probablement le même avantage avec struct {double re, im; }; idiome utilisé en C. Il permet un développement plus rapide, car les opérateurs travaillent sur des types complexes dans fortran.

Je pense que le point clé en faveur de Fortran est qu’il s’agit d’un langage légèrement plus adapté à l’expression de mathématiques basées sur les vecteurs et les tableaux. Le problème d’parsing du pointeur mentionné ci-dessus est réel dans la pratique, car le code portable ne peut pas vraiment supposer que vous pouvez dire quelque chose au compilateur. Il y a TOUJOURS un avantage à exprimer des calculs d’une manière plus proche de l’aspect du domaine. C n’a pas vraiment de tableaux du tout, si vous regardez de près, juste quelque chose qui se comporte comme ça. Fortran a de vrais arrawys. Ce qui facilite la compilation pour certains types d’algorithmes, en particulier pour les machines parallèles.

Au fond des choses comme les systèmes d’exécution et les conventions d’appel, C et Fortran moderne sont suffisamment similaires pour qu’il soit difficile de voir ce qui ferait la différence. Notez que C est vraiment la base C: C ++ est un problème totalement différent avec des caractéristiques de performance très différentes.

Une langue étant plus rapide qu’une autre, la réponse appropriée est non .

Ce que vous devez vraiment demander, c’est “le code compilé avec le compilateur Fortran X est-il plus rapide que le code équivalent compilé avec le compilateur C Y?” La réponse à cette question dépend bien sûr des deux compilateurs que vous choisissez.

Une autre question que l’on pourrait se poser serait celle-ci: “Étant donné le même effort d’effort dans l’optimisation de leurs compilateurs, quel compilateur produirait un code plus rapide?” La réponse à cela serait en fait Fortran . Les compilateurs Fortran présentent des avantages certains:

  • Fortran devait rivaliser avec Assembly dans le jour où certains ont juré de ne jamais utiliser de compilateurs, donc il était conçu pour la vitesse. C a été conçu pour être flexible.
  • Le créneau de Fortran a été difficile. Dans ce domaine, le code n’est jamais assez rapide. Il y a donc toujours eu beaucoup de pression pour que la langue rest efficace.
  • La plupart des recherches sur les optimisations du compilateur sont effectuées par des personnes intéressées par l’accélération du code de calcul Fortran. Par conséquent, l’optimisation du code Fortran est un problème bien plus connu que l’optimisation de tout autre langage compilé.
  • Biggie : C encourage beaucoup plus l’utilisation du pointeur que Fortran. Cela augmente considérablement la scope potentielle de tout élément de données dans un programme C, ce qui les rend beaucoup plus difficile à optimiser. Notez qu’Ada est également bien meilleur que C dans ce domaine, et est un langage OO beaucoup plus moderne que celui que l’on trouve couramment dans Fortran77. Si vous souhaitez une langue OO capable de générer un code plus rapide que C, ceci est une option pour vous.
  • En raison de son créneau important, les clients des compilateurs Fortran ont tendance à se préoccuper davantage de l’optimisation que les clients des compilateurs C.

Cependant, rien n’empêche quelqu’un de mettre une tonne d’effort dans l’optimisation de leur compilateur C et de le faire générer un meilleur code que le compilateur Fortran de leur plate-forme. En fait, les ventes plus importantes générées par les compilateurs C rendent ce scénario tout à fait réalisable.

Il y a un autre élément où Fortran est différent de C – et potentiellement plus rapide. Fortran a de meilleures règles d’optimisation que C. Dans Fortran, l’ordre d’évaluation d’une expression n’est pas défini, ce qui permet au compilateur de l’optimiser – si l’on veut forcer un certain ordre, il faut utiliser des parenthèses. En C, l’ordre est beaucoup plus ssortingct, mais avec les options “-fast”, elles sont plus détendues et “(…)” sont également ignorées. Je pense que Fortran a une manière qui se trouve bien au milieu. (Eh bien, l’IEEE rend la vie plus difficile car certains changements d’ordre d’évaluation nécessitent qu’aucun débordement ne se produise, ce qui doit être ignoré ou entrave l’évaluation).

Les nombres complexes sont un autre domaine des règles plus intelligentes. Non seulement il a fallu attendre C 99 pour que C les ait, mais les règles les gouvernent aussi dans Fortran; Puisque la bibliothèque Fortran de gfortran est partiellement écrite en C mais implémente la sémantique Fortran, GCC a obtenu l’option (qui peut également être utilisée avec les programmes C “normaux”):

-fcx-fortran-rules La multiplication et la division complexes suivent les règles de Fortran. La réduction de la plage est effectuée dans le cadre d’une division complexe, mais il n’y a pas de vérification pour savoir si le résultat d’une multiplication ou d’une division complexe est “NaN + I * NaN”, avec une tentative de sauvetage de la situation.

Les règles d’alias mentionnées ci-dessus sont un autre bonus et aussi, du moins en principe, les opérations sur tout le tableau, qui, si elles sont correctement sockets en compte par l’optimiseur du compilateur, peuvent entraîner un code plus rapide. Par contre, certaines opérations prennent plus de temps, par exemple si l’on fait une affectation à un tableau pouvant être alloué, il y a beaucoup de vérifications nécessaires (réallouer? [Fonctionnalité Fortran 2003], a les foulées du tableau, etc.) opération simple plus complexe dans les coulisses – et donc plus lente, mais rend le langage plus puissant. D’autre part, les opérations de tableau avec des limites et des foulées flexibles facilitent l’écriture du code – et le compilateur optimise généralement mieux le code qu’un utilisateur.

Au total, je pense que C et Fortran sont à peu près aussi rapides; le choix devrait être plutôt de savoir quelle langue est-ce que l’on aime le plus ou si l’utilisation des opérations de tableau entier de Fortran et sa meilleure portabilité sont plus utiles – ou la meilleure interface avec les bibliothèques de système et d’interface graphique utilisateur en C.

Il n’y a rien dans les langages Fortran et C qui en fait un plus rapide que l’autre à des fins spécifiques. Il y a des choses sur des compilateurs spécifiques pour chacune de ces langues, qui en font plus que d’autres pour certaines tâches.

Pendant de nombreuses années, il existait des compilateurs Fortran capables de faire de la magie noire à vos routines numériques, rendant beaucoup de calculs importants incroyablement rapides. Les compilateurs C contemporains ne pouvaient pas le faire aussi bien. En conséquence, plusieurs grandes bibliothèques de code ont vu le jour dans Fortran. Si vous voulez utiliser ces bibliothèques bien testées, matures et merveilleuses, vous devez sortir le compilateur Fortran.

Mes observations informelles montrent que ces jours-ci, les gens codent leurs trucs de calcul lourds dans n’importe quelle langue, et si cela prend du temps, ils trouvent du temps sur un cluster de calcul bon marché. La loi de Moore nous rend tous fous.

Je compare la vitesse de Fortran, C et C ++ avec le benchmark classique Levine-Callahan-Dongarra de netlib. La version en plusieurs langues, avec OpenMP, est la suivante : http://sites.google.com/site/tprincesite/levine-callahan-dongarra-vectors. compilateurs. C ++ est juste C avec les modèles STL, le cas échéant. À mon avis, la STL est un sac mixte quant à savoir si elle améliore la maintenabilité.

Il n’ya qu’un minimum d’exercices d’instruction automatique des fonctions pour voir dans quelle mesure cela améliore l’optimisation, puisque les exemples sont basés sur la pratique traditionnelle de Fortran où l’on accorde peu d’importance à l’intégration.

Le compilateur C / C ++, dont l’utilisation est de loin la plus répandue, manque d’auto-vectorisation, sur laquelle ces tests s’appuient fortement.

Re le post qui vient juste avant cela: il y a quelques exemples où les parenthèses sont utilisées dans Fortran pour dicter l’ordre d’évaluation plus rapide ou plus précis. Les compilateurs C connus n’ont pas les options pour observer les parenthèses sans désactiver les optimisations plus importantes.

Je faisais des mathématiques approfondies avec FORTRAN et C pendant quelques années. De ma propre expérience, je peux dire que FORTRAN est parfois vraiment meilleur que C mais pas pour sa vitesse (on peut faire en sorte que C fonctionne aussi vite que FORTRAN en utilisant un style de codage approprié) mais plutôt grâce à des bibliothèques très optimisées comme LAPACK. grande parallélisation. À mon avis, FORTRAN est vraiment difficile à utiliser et ses avantages ne sont pas suffisants pour annuler cet inconvénient. J’utilise maintenant C + GSL pour faire des calculs.

Je suis un programmeur amateur et je suis “moyen” dans les deux langues. Je trouve plus facile d’écrire du code Fortran rapide que du code C (ou C ++). Fortran et C sont tous deux des langages “historiques” (par la norme actuelle), sont très utilisés et ont un compilateur gratuit et commercial bien supporté.

Je ne sais pas si c’est un fait historique, mais Fortran a l’impression qu’il est conçu pour être mis en parallèle / dissortingbué / vectorisé / peu importe le kernel. Et aujourd’hui, c’est à peu près la “mésortingque standard” quand on parle de vitesse: “est-ce que ça évolue?”

Pour pur cpu crunching j’aime Fortran. Pour tout ce qui concerne les IO, je trouve plus facile de travailler avec C. (c’est difficile dans les deux cas).

Maintenant, bien sûr, pour un code parallèle de calcul intensif, vous voudrez probablement utiliser votre GPU. C et Fortran ont tous deux une interface CUDA / OpenCL plus ou moins bien intégrée (et maintenant OpenACC).

Ma réponse modérément objective est la suivante: si vous connaissez les deux langues également bien / mal, je pense que Fortran est plus rapide car je trouve plus facile d’écrire du code parallèle / dissortingbué que Fortran (une fois que vous avez compris pas seulement le code F77 ssortingct)

Voici une deuxième réponse pour ceux qui voudraient me retirer parce qu’ils n’aiment pas la 1ère réponse: les deux langues ont les caractéristiques requirejses pour écrire du code haute performance. Donc, cela dépend de l’algorithme que vous implémentez (processeur intensif? Intensif? Mémoire intensive?), Du matériel (processeur unique? Multi-cœur? Supercalculateur? GPGPU? FPGA?), De vos compétences et finalement du compilateur lui-même. C et Fortran ont tous deux un compilateur génial. (Je suis vraiment étonné de voir à quel point les compilateurs Fortran sont avancés, mais les compilateurs C aussi).

PS: Je suis content que vous ayez spécifiquement exclu les libs car j’ai beaucoup de choses à dire sur les librairies de Fortran. 🙂

Je n’ai pas entendu dire que Fortan est nettement plus rapide que C, mais il pourrait être concevable que dans certains cas, ce soit plus rapide. Et la clé n’est pas dans les fonctionnalités linguistiques qui sont présentes, mais dans celles qui (généralement) absentes.

Un exemple sont les pointeurs C. Les pointeurs C sont utilisés presque partout, mais le problème avec les pointeurs est que le compilateur ne peut généralement pas dire s’ils pointent vers les différentes parties du même tableau.

Par exemple, si vous avez écrit une routine strcpy qui ressemblait à ceci:

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

Le compilateur doit travailler en supposant que les d et s peuvent se chevaucher. Il ne peut donc pas effectuer une optimisation qui produirait des résultats différents lorsque les tableaux se chevauchent. Comme on peut s’y attendre, cela limite considérablement le type d’optimisations pouvant être effectuées.

[Je devrais noter que C99 a un mot-clé “ressortingct” qui indique explicitement aux compilateurs que les pointeurs ne se chevauchent pas. Notez également que le Fortran a aussi des pointeurs, avec une sémantique différente de celle de C, mais les pointeurs ne sont pas omniprésents comme dans C.]

Mais revenant à la question C vs. Fortran, il est concevable qu’un compilateur Fortran soit capable d’effectuer des optimisations qui pourraient ne pas être possibles pour un programme C (écrit directement). Je ne serais donc pas trop surpris par la revendication. Cependant, je pense que la différence de performance ne serait pas si importante. [~ 5-10%]

Toute différence de vitesse entre Fortran et C dépendra davantage des optimisations du compilateur et de la bibliothèque mathématique sous-jacente utilisée par le compilateur particulier. Il n’y a rien insortingnsèque à Fortran qui le rendrait plus rapide que C.

Quoi qu’il en soit, un bon programmeur peut écrire Fortran dans n’importe quelle langue.

Simple et rapide: les deux sont également rapides, mais Fortran est plus simple. Quoi de plus rapide à la fin dépend de l’algorithme, mais il n’y a pas de différence de vitesse considérable de toute façon. C’est ce que j’ai appris en 2015 dans un atelier Fortran du centre de calcul haute performance Stuttgard, en Allemagne. Je travaille à la fois avec Fortran et C et partage cette opinion.

Explication:

C a été conçu pour écrire des systèmes d’exploitation. Par conséquent, il a plus de liberté que nécessaire pour écrire du code haute performance. En général, cela ne pose aucun problème, mais si on ne programme pas avec soin, on peut facilement ralentir le code.

Fortran a été conçu pour la programmation scientifique. Pour cette raison, il prend en charge l’écriture rapide de la syntaxe du code, car c’est le but principal de Fortran. Contrairement à l’opinion publique, Fortran n’est pas un langage de programmation obsolète. Son dernier standard est 2010 et de nouveaux compilateurs sont publiés régulièrement, la plupart des codes haute performance étant écrits dans Fortran. Fortran prend également en charge les fonctionnalités modernes en tant que directives de compilation (en pragmas C).

Exemple: Nous voulons donner une grande structure en tant qu’argument d’entrée à une fonction (fortran: sous-routine). Dans la fonction, l’argument n’est pas modifié.

C prend en charge les deux, appel par référence et appel par valeur, qui est une fonctionnalité pratique. Dans notre cas, le programmeur peut, par accident, utiliser l’appel par valeur. Cela ralentit considérablement les choses, car la structure doit d’abord être copiée dans la mémoire.

Fortran travaille uniquement avec l’appel par référence, ce qui oblige le programmeur à copier la structure manuellement, s’il souhaite réellement une opération appel par valeur. Dans notre cas, fortran sera automatiquement aussi rapide que la version C avec appel par référence.

Generally FORTRAN is slower than C. C can use hardware level pointers allowing the programmer to hand-optimize. FORTRAN (in most cases) doesn’t have access to hardware memory addressing hacks. (VAX FORTRAN is another story.) I’ve used FORTRAN on and off since the ’70’s. (Really.)

However, starting in the 90’s FORTRAN has evolved to include specific language constructs that can be optimized into inherently parallel algorithms that can really scream on a multi-core processor. For example, automatic Vectorizing allows multiple processors to handle each element in a vector of data concurrently. 16 processors — 16 element vector — processing takes 1/16th the time.

In C, you have to manage your own threads and design your algorithm carefully for multi-processing, and then use a bunch of API calls to make sure that the parallelism happens properly.

In FORTRAN, you only have to design your algorithm carefully for multi-processing. The comstackr and run-time can handle the rest for you.

You can read a little about High Performance Fortran , but you find a lot of dead links. You’re better off reading about Parallel Programming (like OpenMP.org ) and how FORTRAN supports that.

The faster code is not really up to the language, is the comstackr so you can see the ms-vb “comstackr” that generates bloated, slower and redundant object code that is tied together inside an “.exe”, but powerBasic generates too way better code. Object code made by a C and C++ comstackrs is generated in some phases (at least 2) but by design most Fortran comstackrs have at least 5 phases including high-level optimizations so by design Fortran will always have the capability to generate highly optimized code. So at the end is the comstackr not the language you should ask for, the best comstackr i know is the Intel Fortran Comstackr because you can get it on LINUX and Windows and you can use VS as the IDE, if you’re looking for a cheap tigh comstackr you can always relay on OpenWatcom.

More info about this: http://ed-thelen.org/1401Project/1401-IBM-Systems-Journal-FORTRAN.html

Fortran has better I/O routines, eg the implied do facility gives flexibility that C’s standard library can’t match.

The Fortran comstackr directly handles the more complex syntax involved, and as such syntax can’t be easily reduced to argument passing form, C can’t implement it efficiently.

Most of the posts already present compelling arguments, so I will just add the proverbial 2 cents to a different aspect.

Being fortran faster or slower in terms of processing power in the end can have its importance, but if it takes 5 times more time to develop something in Fortran because:

  • it lacks any good library for tasks different from pure number crunching
  • it lack any decent tool for documentation and unit testing
  • it’s a language with very low expressivity, skyrocketing the number of lines of code.
  • it has a very poor handling of ssortingngs
  • it has an inane amount of issues among different comstackrs and architectures driving you crazy.
  • it has a very poor IO strategy (READ/WRITE of sequential files. Yes, random access files exist but did you ever see them used?)
  • it does not encourage good development practices, modularization.
  • effective lack of a fully standard, fully compliant opensource comstackr (both gfortran and g95 do not support everything)
  • very poor interoperability with C (mangling: one underscore, two underscores, no underscore, in general one underscore but two if there’s another underscore. and just let not delve into COMMON blocks…)

Then the issue is irrelevant. If something is slow, most of the time you cannot improve it beyond a given limit. If you want something faster, change the algorithm. In the end, computer time is cheap. Human time is not. Value the choice that reduces human time. If it increases computer time, it’s cost effective anyway.

Using modern standards and comstackr, no!

Some of the folks here have suggested that FORTRAN is faster because the comstackr doesn’t need to worry about aliasing (and hence can make more assumptions during optimisation). However, this has been dealt with in C since the C99 (I think) standard with the inclusion of the ressortingct keyword. Which basically tells the comstackr, that within a give scope, the pointer is not aliased. Furthermore C enables proper pointer arithmetic, where things like aliasing can be very useful in terms of performance and resource allocation. Although I think more recent version of FORTRAN enable the use of “proper” pointers.

For modern implementations C general outperforms FORTRAN (although it is very fast too).

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

MODIFIER:

A fair criticism of this seems to be that the benchmarking may be biased. Here is another source (relative to C) that puts result in more context:

http://julialang.org/benchmarks/

You can see that C typically outperforms Fortran in most instances (again see criticisms below that apply here too); as others have stated, benchmarking is an inexact science that can be easily loaded to favour one language over others. But it does put in context how Fortran and C have similar performance.

This is more than somewhat subjective, because it gets into the quality of comstackrs and such more than anything else. However, to more directly answer your question, speaking from a language/comstackr standpoint there is nothing about Fortran over C that is going to make it inherently faster or better than C. If you are doing heavy math operations, it will come down to the quality of the comstackr, the skill of the programmer in each language and the insortingnsic math support libraries that support those operations to ultimately determine which is going to be faster for a given implementation.

EDIT: Other people such as @Nils have raised the good point about the difference in the use of pointers in C and the possibility for aliasing that perhaps makes the most naive implementations slower in C. However, there are ways to deal with that in C99, via comstackr optimization flags and/or in how the C is actually written. This is well covered in @Nils answer and the subsequent comments that follow on his answer.

Fortran can handle array, especially multidimensional arrays, very conveniently. Slicing elements of multidimensional array in Fortran can be much easier than that in C/C++. C++ now has libraries can do the job, such as Boost or Eigen, but they are after all external libraries. In Fortran these functions are insortingnsic.

Whether Fortran is faster or more convenient for developing mostly depends on the job you need to finish. As a scientific computation person for geophysics, I did most of computation in Fortran (I mean modern Fortran, >=F90).

Fortran traditionally doesn’t set options such as -fp:ssortingct (which ifort requires to enable some of the features in USE IEEE_arithmetic, a part of f2003 standard). Intel C++ also doesn’t set -fp:ssortingct as a default, but that is required for ERRNO handling, for example, and other C++ comstackrs don’t make it convenient to turn off ERRNO or gain optimizations such as simd reduction. gcc and g++ have required me to set up Makefile to avoid using the dangerous combination -O3 -ffast-math -fopenmp -march=native. Other than these issues, this question about relative performance gets more nit-picky and dependent on local rules about choice of comstackrs and options.