Фортран легче оптимизировать, чем C, для тяжелых вычислений?

Любые различия в скорости между Fortran и C будут больше зависеть от оптимизации компилятора и базовой математической библиотеки, используемой конкретным компилятором. В Fortran нет ничего такого, что могло бы сделать его быстрее, чем C.

В любом случае хороший программист может написать Фортран на любом языке.

Это более чем несколько субъективно, потому что больше всего влияет на качество компиляторов и тому подобное. Однако, чтобы более прямо ответить на ваш вопрос, говоря с точки зрения языка / компилятора, в Fortran нет ничего, что могло бы сделать его по своей сути быстрее или лучше, чем C.Если вы выполняете тяжелые математические операции, все сводится к качество компилятора, навыки программиста на каждом языке и встроенные математические вспомогательные библиотеки, которые поддерживают эти операции, чтобы в конечном итоге определить, что будет быстрее для данной реализации.

Обновлено: другие люди, такие как @Nils, подняли хороший вопрос о разнице в использовании указателей в C и возможности сглаживания, что, возможно, замедляет самые наивные реализации в C. Однако есть способы справиться с этим в C99. , через флаги оптимизации компилятора и / или в том, как на самом деле написан C. Это хорошо освещено в ответе @Nils и последующих комментариях, которые следуют за его ответом.

У языков схожий набор функций. Разница в производительности происходит из-за того, что Fortran говорит, что использование псевдонимов недопустимо, если не используется оператор EQUIVALENCE. Любой код с псевдонимом не является допустимым для Fortran, но определение этих ошибок зависит от программиста, а не от компилятора. Таким образом, компиляторы Fortran игнорируют возможное наложение указателей на память и позволяют им генерировать более эффективный код. Взгляните на этот небольшой пример на 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;
    }
}

Эта функция после оптимизации будет работать медленнее, чем ее аналог на Фортране. Почему так? Если вы записываете значения в выходной массив, вы можете изменить значения матрицы. В конце концов, указатели могут перекрываться и указывать на один и тот же кусок памяти (включая указатель int!). Компилятор C вынужден перезагружать четыре значения матрицы из памяти для всех вычислений.

В Фортране компилятор может загружать значения матрицы один раз и сохранять их в регистрах. Это возможно, потому что компилятор Fortran предполагает, что указатели / массивы не перекрываются в памяти.

К счастью, ключевое слово restrict и строгий псевдоним были введены в стандарт C99 для решения этой проблемы. В наши дни он также хорошо поддерживается большинством компиляторов C++. Ключевое слово позволяет вам дать компилятору подсказку, которую программист обещает, что указатель не совпадает с каким-либо другим указателем. Строгий псевдоним означает, что программист обещает, что указатели разных типов никогда не будут перекрываться, например, double* не будет перекрываться с int* (с конкретным исключением, что char* и void* могут перекрываться с чем угодно).

Если вы используете их, вы получите одинаковую скорость от C и Fortran. Однако возможность использовать ключевое слово restrict только с функциями, критичными к производительности, означает, что программы на C (и C++) намного безопаснее и проще в написании. Например, рассмотрим недопустимый код Fortran: CALL TRANSFORM(A(1, 30), A(2, 31), A(3, 32), 30), который большинство компиляторов Fortran с радостью компилируют без каких-либо предупреждений, но вносит ошибку, которая проявляется только в некоторых компиляторах, на некотором оборудовании и с некоторыми параметрами оптимизации.

Я не слышал, что Fortan значительно быстрее, чем C, но можно предположить, что в некоторых случаях он будет быстрее. И дело не в языковых функциях, которые присутствуют, а в тех, которые (обычно) отсутствуют.

Примером являются указатели C. Указатели C используются практически везде, но проблема с указателями заключается в том, что компилятор обычно не может определить, указывают ли они на разные части одного и того же массива.

Например, если вы написали подпрограмму strcpy, которая выглядела так:

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

Компилятор должен работать в предположении, что d и s могут перекрывать массивы. Таким образом, он не может выполнить оптимизацию, которая дала бы разные результаты при перекрытии массивов. Как и следовало ожидать, это значительно ограничивает виды оптимизаций, которые могут быть выполнены.

[Я должен отметить, что в C99 есть ключевое слово restrict, которое явно сообщает компиляторам, что указатели не перекрываются. Также обратите внимание, что в Fortran тоже есть указатели с семантикой, отличной от семантики C, но указатели не являются повсеместными, как в C.]

Но, возвращаясь к проблеме C и Fortran, вполне возможно, что компилятор Fortran может выполнять некоторые оптимизации, которые могут быть невозможны для (прямо написанной) программы на C. Так что я не был бы слишком удивлен заявлением. Однако я действительно ожидаю, что разница в производительности будет не такой уж большой. [~ 5-10%]

Обычно FORTRAN медленнее, чем C. C может использовать указатели аппаратного уровня, позволяя программисту оптимизировать вручную. FORTRAN (в большинстве случаев) не имеет доступа к аппаратным взломам адресации памяти. (VAX FORTRAN - это отдельная история.) Я использовал FORTRAN время от времени с 70-х годов. (Действительно.)

Однако, начиная с 90-х годов, FORTRAN эволюционировал и стал включать в себя определенные языковые конструкции, которые можно оптимизировать в по сути параллельные алгоритмы, которые может действительно кричит на многоядерном процессоре. Например, автоматическая векторизация позволяет нескольким процессорам одновременно обрабатывать каждый элемент вектора данных. 16 процессоров - 16 векторных элементов - обработка занимает 1/16 часть времени.

В C вы должны управлять своими собственными потоками и тщательно разрабатывать свой алгоритм для многопроцессорной обработки, а затем использовать набор вызовов API, чтобы убедиться, что параллелизм происходит должным образом.

В FORTRAN вам нужно только тщательно разработать свой алгоритм для множественной обработки. Все остальное компилятор и среда выполнения могут сделать за вас.

Вы можете немного почитать о Высокопроизводительный Фортран, но вы найдете много мертвых ссылок. Вам лучше прочитать о параллельном программировании (например, OpenMP.org) и о том, как FORTRAN это поддерживает.

В языки Fortran и C нет ничего, что делало бы один быстрее другого для определенных целей. Есть особенности составители для каждого из этих языков, которые делают одни более подходящими для определенных задач, чем другие.

В течение многих лет существовали компиляторы Fortran, которые могли творить черную магию с вашими числовыми подпрограммами, делая многие важные вычисления безумно быстрыми. Современные компиляторы Си тоже не могли этого сделать. В результате на Фортране выросло количество отличных библиотек кода. Если вы хотите использовать эти хорошо протестированные, зрелые, замечательные библиотеки, вы можете использовать компилятор Fortran.

Мои неофициальные наблюдения показывают, что в наши дни люди кодируют свои тяжелые вычислительные материалы на любом старом языке, и если это требует времени, они находят время на каком-нибудь дешевом вычислительном кластере. Закон Мура делает всех нас дураками.

Есть несколько причин, по которым Фортран может быть быстрее. Однако количество, которое они имеют значение, настолько несущественно, или его можно обойти в любом случае, что это не должно иметь значения. Основная причина использования Fortran в настоящее время - поддержка или расширение унаследованных приложений.

• Ключевые слова PURE и ELEMENTAL в функциях. Это функции, у которых нет побочных эффектов. Это позволяет проводить оптимизацию в определенных случаях, когда компилятор знает, что одна и та же функция будет вызываться с одинаковыми значениями. Примечание: GCC реализует «чистый» как расширение языка. Другие компиляторы тоже могут. Межмодульный анализ также может выполнять эту оптимизацию, но это сложно.

• стандартный набор функций, которые работают с массивами, а не с отдельными элементами. Такие вещи, как sin (), log (), sqrt (), принимают массивы вместо скаляров. Это упрощает оптимизацию распорядка. Автоматическая векторизация дает те же преимущества в большинстве случаев, если эти функции являются встроенными или встроенными.

• Встроенный комплексного типа. Теоретически это может позволить компилятору переупорядочивать или удалять определенные инструкции в определенных случаях, но, вероятно, вы увидите такое же преимущество с идиомой struct { double re; double im; };, используемой в C. Это ускоряет разработку, хотя операторы работают со сложными типами в Фортране.

Я думаю, что ключевым моментом в пользу Фортрана является то, что это язык, немного более подходящий для выражения математики на основе векторов и массивов. Указанная выше проблема анализа указателя реальна на практике, поскольку переносимый код не может действительно предполагать, что вы можете что-то сообщить компилятору. Вычисления выражений ВСЕГДА имеют преимущество, близкое к тому, как выглядит домен. В C на самом деле вообще нет массивов, если вы присмотритесь, просто что-то подобное ведет себя. У Фортрана есть реальные массивы. Это упрощает компиляцию для определенных типов алгоритмов, особенно для параллельных машин.

Глубоко в таких вещах, как система времени выполнения и соглашения о вызовах, C и современный Фортран достаточно похожи, так что трудно понять, что может иметь значение. Обратите внимание, что C здесь действительно базовый C: C++ - это совершенно другая проблема с очень разными характеристиками производительности.

Да, в 1980 году; в 2008? зависит

Когда я начал профессионально программировать, доминирование Фортрана в скорости было только вызовом. Помню, как читая об этом в Докторе Доббсе рассказывал про статью старшим программистам - они смеялись.

Так что у меня есть две точки зрения на этот счет: теоретическая и практическая. В теории Фортран сегодня не имеет существенных преимуществ перед C / C++ или даже любым языком, допускающим ассемблерный код. На практике Фортран сегодня по-прежнему пользуется преимуществами наследия истории и культуры, построенных на оптимизации числового кода.

Вплоть до Fortran 77 включительно при проектировании языка основное внимание уделялось оптимизации. Из-за состояния теории и технологии компиляторов это часто означало функции и возможности ограничение, чтобы дать компилятору наилучшие возможности для оптимизации кода. Хорошая аналогия - подумать о Fortran 77 как о профессиональном гоночном автомобиле, который жертвует характеристиками ради скорости. В наши дни компиляторы стали лучше на всех языках, и функции, повышающие продуктивность программистов, стали более ценными. Тем не менее, есть места, где люди в основном озабочены скоростью научных вычислений; эти люди, скорее всего, унаследовали код, обучение и культуру от людей, которые сами были программистами на Фортране.

Когда кто-то начинает говорить об оптимизации кода, возникает множество проблем, и лучший способ понять это - прятаться там, где есть люди, чья работа заключается в быстром числовом коде. Но имейте в виду, что такой критически чувствительный код обычно составляет небольшую часть общих строк кода и очень специализирован: большая часть кода на Фортране так же «неэффективна», как и многие другие коды на других языках и Оптимизация даже не должна быть основной задачей такого кода..

Замечательное место для начала изучения истории и культуры Фортрана - это Википедия. Запись Fortran в Википедии превосходен, и я очень ценю тех, кто потратил время и усилия, чтобы сделать его полезным для сообщества Fortran.

(Укороченная версия этого ответа была бы комментарием в отличной ветке, начатой ​​Нильс, но у меня нет кармы, чтобы сделать это. На самом деле, я бы, вероятно, вообще ничего бы не написал, если бы в этой ветке не было фактических информационный контент и обмен информацией в отличие от пламенных войн и языкового фанатизма, что является моим основным опытом в этой теме. Я был потрясен, и мне пришлось разделить эту любовь.)

Есть еще один пункт, в котором Фортран отличается от C - и потенциально быстрее. В Фортране правила оптимизации лучше, чем в C. В Фортране порядок вычисления выражений не определен, что позволяет компилятору оптимизировать его - если кто-то хочет принудительно установить определенный порядок, нужно использовать круглые скобки. В C порядок намного строже, но с опциями «-fast» они более расслаблены, и «(...)» также игнорируются. Я думаю, что у Фортрана есть способ, который хорошо лежит посередине. (Что ж, IEEE усложняет жизнь, поскольку некоторые изменения порядка оценки требуют, чтобы не происходило переполнения, которое либо следует игнорировать, либо затрудняет оценку).

Еще одна область более разумных правил - комплексные числа. Мало того, что только до C 99 они были у C, еще и правила, управляющие ими, стали лучше в Фортране; поскольку библиотека Fortran gfortran частично написана на C, но реализует семантику Fortran, GCC получил возможность (которая также может использоваться с "обычными" программами на C):

-fcx-fortran-rules Complex multiplication and division follow Fortran rules. Range reduction is done as part of complex division, but there is no checking whether the result of a complex multiplication or division is "NaN + I*NaN", with an attempt to rescue the situation in that case.

Упомянутые выше правила псевдонимов - это еще один бонус, а также - по крайней мере в принципе - операции с целым массивом, которые, если их должным образом учитывать оптимизатором компилятора, могут привести к более быстрому выполнению кода. С другой стороны, некоторые операции занимают больше времени, например если кто-то выполняет присвоение размещаемому массиву, необходимо выполнить множество проверок (перераспределить? [функция Fortran 2003], есть шаги массива и т. д.), которые делают простую операцию более сложной за кулисами - и, следовательно, медленнее, но делает язык более мощным. С другой стороны, операции с массивами с гибкими границами и шагами упрощают написание кода - и компилятор обычно лучше оптимизирует код, чем пользователь.

В целом, я думаю, что и C, и Fortran примерно одинаково быстры; выбор должен заключаться в том, какой язык больше нравится, или более полезно использовать операции с целым массивом Fortran и его лучшая переносимость - или лучший интерфейс с системными библиотеками и библиотеками графического пользовательского интерфейса в C.

Я сравниваю скорость Fortran, C и C++ с классическим тестом Levine-Callahan-Dongarra из netlib. Многоязычная версия с OpenMP http://sites.google.com/site/tprincesite/levine-callahan-dongarra-vectors C уродливее, поскольку он начинался с автоматического перевода, плюс добавление ограничений и прагм для некоторых компиляторов. C++ - это просто C с шаблонами STL, где это применимо. На мой взгляд, STL представляет собой неоднозначную картину относительно того, улучшает ли он ремонтопригодность.

Существует лишь минимальное упражнение по автоматическому встраиванию функций, чтобы увидеть, в какой степени это улучшает оптимизацию, поскольку примеры основаны на традиционной практике Фортрана, в которой мало полагаются на встраивание.

Компилятор C / C++, который наиболее широко используется, не имеет автоматической векторизации, от которой в значительной степени зависят эти тесты.

Повторите сообщение, появившееся непосредственно перед этим: есть несколько примеров, когда скобки используются в Фортране, чтобы указать более быстрый или более точный порядок оценки. Известные компиляторы C не имеют возможности наблюдать за круглыми скобками без отключения более важных оптимизаций.

Не бывает такого понятия, как один язык быстрее другого, поэтому правильный ответ - нет.

На самом деле вам нужно спросить, «скомпилирован ли код с помощью компилятора Fortran X быстрее, чем эквивалентный код, скомпилированный с помощью компилятора C Y?» Ответ на этот вопрос, конечно, зависит от того, какие два компилятора вы выберете.

Другой вопрос, который можно было бы задать, был бы примерно такой: «Учитывая то же количество усилий, затраченных на оптимизацию в их компиляторах, какой компилятор будет производить более быстрый код?» Фактически ответом на это будет Фортран. Компиляторы Fortran имеют определенные преимущества:

• Fortran приходилось конкурировать с Assembly в те времена, когда некоторые клялись никогда не использовать компиляторы, поэтому он был разработан для скорости. C был разработан, чтобы быть гибким.
• Ниша Фортрана постоянно сокращается. В этом домене код никогда достаточно быстрый. Так что всегда было большое давление, чтобы язык оставался эффективным.
• Большая часть исследований по оптимизации компилятора проводится людьми, заинтересованными в ускорении кода обработки чисел Fortran, поэтому оптимизация кода Fortran - гораздо более известная проблема, чем оптимизация любого другого компилируемого языка, и новые инновации сначала появляются в компиляторах Fortran.
• Biggie: C поощряет использование гораздо большего количества указателей, чем Fortran. Это резко увеличивает потенциальный объем любого элемента данных в программе на языке C, что значительно затрудняет их оптимизацию. Обратите внимание, что Ada также намного лучше, чем C в этой области, и является гораздо более современным языком OO, чем обычно встречающийся Fortran77. Если вам нужен объектно-ориентированный язык, который может генерировать более быстрый код, чем C, это вариант для вас.
• Опять же, из-за своей ниши, требующей большого количества вычислений, клиенты компиляторов Fortran, как правило, больше заботятся об оптимизации, чем клиенты компиляторов C.

Однако ничто не мешает кому-то приложить массу усилий для оптимизации своего компилятора C и заставить его генерировать лучший код, чем компилятор Fortran их платформы. Фактически, более крупные продажи компиляторов C делают этот сценарий вполне осуществимым.

В некоторой степени Fortran был разработан с учетом оптимизации компилятора. Язык поддерживает операции с целым массивом, в которых компиляторы могут использовать параллелизм (особенно на многоядерных процессорах). Например,

Плотное матричное умножение просто:

matmul(a,b)

L2 норма вектора x равна:

sqrt(sum(x**2))

Кроме того, такие инструкции, как процедуры FORALL, PURE, ELEMENTAL и т. д., Дополнительно помогают оптимизировать код. Даже указатели в Fortran не так гибки, как C, по этой простой причине.

В грядущем стандарте Fortran (2008) есть сопряженные массивы, которые позволяют легко писать параллельный код. G95 (с открытым исходным кодом) и компиляторы от CRAY уже поддерживают его.

Так что да, Fortran может быть быстрым просто потому, что компиляторы могут оптимизировать / распараллеливать его лучше, чем C / C++. Но опять же, как и все в жизни, есть хорошие компиляторы и плохие компиляторы.

Большинство сообщений уже содержат убедительные аргументы, поэтому я просто добавлю пресловутые 2 цента к другому аспекту.

Быть fortran быстрее или медленнее с точки зрения вычислительной мощности, в конце концов, может иметь важное значение, но если для разработки чего-либо в Fortran требуется в 5 раз больше времени, потому что:

• ему не хватает хорошей библиотеки для задач, отличных от простого вычисления чисел
• в нем нет достойного инструмента для документации и модульного тестирования
• это язык с очень низкой выразительностью, стремительно увеличивающим количество строк кода.
• у него очень плохая обработка строк
• у него есть бессмысленное количество проблем между разными компиляторами и архитектурами, которые сводят вас с ума.
• у него очень плохая стратегия ввода-вывода (ЧТЕНИЕ / ЗАПИСЬ последовательных файлов. Да, файлы с произвольным доступом существуют, но вы когда-нибудь видели их использование?)
• он не поощряет хорошие практики разработки, модульность.
• эффективное отсутствие полностью стандартного, полностью совместимого компилятора с открытым исходным кодом (и gfortran, и g95 не поддерживают все)
• очень плохая совместимость с C (искажение: одно подчеркивание, два подчеркивания, без подчеркивания, в общем одно подчеркивание, но два, если есть другое подчеркивание. и просто не позволяйте углубляться в ОБЩИЕ блоки ...)

Тогда вопрос неактуален. Если что-то работает медленно, в большинстве случаев вы не можете улучшить это сверх заданного предела. Если вы хотите что-то побыстрее, измените алгоритм. В конце концов, компьютерное время стоит недорого. Человеческого времени нет. Цените выбор, который сокращает человеческое время. Если это увеличивает время работы компьютера, это в любом случае рентабельно.

Более быстрый код на самом деле не зависит от языка, это компилятор, поэтому вы можете увидеть «компилятор» ms-vb, который генерирует раздутый, более медленный и избыточный объектный код, связанный вместе внутри «.exe», но powerBasic генерирует тоже лучший код. Объектный код, созданный компиляторами C и C++, генерируется на некоторых этапах (по крайней мере, 2), но по замыслу большинство компиляторов Fortran имеют как минимум 5 этапов, включая высокоуровневую оптимизацию, поэтому по замыслу Fortran всегда будет иметь возможность генерировать высокооптимизированный код. Итак, в конце концов, это компилятор, а не тот язык, о котором вы должны просить, лучший компилятор, который я знаю, - это компилятор Intel Fortran, потому что вы можете получить его в LINUX и Windows, и вы можете использовать VS в качестве IDE, если вы ищете дешевый жесткий компилятор, который вы всегда можете передать на OpenWatcom.

Подробнее об этом: http://ed-thelen.org/1401Project/1401-IBM-Systems-Journal-FORTRAN.html

Пару лет я занимался математикой с помощью FORTRAN и C. По собственному опыту могу сказать, что FORTRAN иногда действительно лучше C, но не из-за его скорости (можно заставить C работать так же быстро, как FORTRAN, используя соответствующий стиль кодирования), а из-за очень хорошо оптимизированных библиотек, таких как LAPACK, и из-за отличное распараллеливание. На мой взгляд, с FORTRAN действительно неудобно работать, и его преимуществ недостаточно, чтобы устранить этот недостаток, поэтому теперь я использую C + GSL для вычислений.

Забавно, что здесь много ответов от незнания языков. Это особенно верно для программистов C / C++, которые открыли старый код FORTRAN 77 и обсуждают слабые места.

Я полагаю, что проблема скорости - это в основном вопрос между C / C++ и Fortran. В огромном коде это всегда зависит от программиста. Есть некоторые особенности языка, которые Фортран превосходит, и некоторые особенности, которые делает C. Итак, в 2011 году никто не может сказать, какая из них быстрее.

Что касается самого языка, Fortran в настоящее время поддерживает все функции ООП и полностью обратно совместим. Я тщательно использовал Fortran 2003, и я бы сказал, что пользоваться им было просто приятно. В некоторых аспектах Fortran 2003 все еще отстает от C++, но давайте посмотрим на его использование. Fortran в основном используется для численных вычислений, и никто не использует причудливые функции C++ ООП из-за соображений скорости. В высокопроизводительных вычислениях C++ почти некуда идти (взгляните на стандарт MPI, и вы увидите, что C++ устарел!).

В настоящее время вы можете просто программировать смешанные языки с помощью Fortran и C / C++. В Fortran есть даже интерфейсы для GTK +. Есть бесплатные компиляторы (gfortran, g95) и много отличных коммерческих.

У Fortran есть лучшие процедуры ввода-вывода, например подразумеваемая возможность do дает гибкость, которой не может соответствовать стандартная библиотека C.

Компилятор Fortran напрямую обрабатывает более сложные задействован синтаксис, и поэтому синтаксис не может быть легко сокращен в форму передачи аргументов, C не может реализовать это эффективно.

Фортран традиционно не устанавливает такие параметры, как -fp: strict (которые ifort требует включения некоторых функций в USE IEEE_arithmetic, части стандарта f2003). Intel C++ также не устанавливает -fp: strict по умолчанию, но это требуется, например, для обработки ERRNO, а другие компиляторы C++ не позволяют удобно отключить ERRNO или получить оптимизацию, такую ​​как сокращение simd. gcc и g ++ потребовали от меня настроить Makefile, чтобы избежать использования опасной комбинации -O3 -ffast-math -fopenmp -march = native. Помимо этих проблем, этот вопрос об относительной производительности становится более придирчивым и зависит от местных правил выбора компиляторов и опций.

Я программист-любитель, и я "средний" по обоим языкам. Мне легче писать быстрый код на Фортране, чем код на C (или C++). И Fortran, и C являются "историческими" языками (по сегодняшнему стандарту), широко используются и имеют хорошо поддерживаемые бесплатные и коммерческие компиляторы.

Я не знаю, исторический ли это факт, но Фортран кажется, что он построен для параллельной / распределенной / векторизации / любой-много-ядерной. И сегодня, когда мы говорим о скорости, это в значительной степени «стандартная метрика»: «масштабируется ли она?»

Я люблю Fortran за чистую обработку процессора. Для всего, что связано с вводом-выводом, мне легче работать с C. (в любом случае это сложно в обоих случаях).

Теперь, конечно, для параллельного математического кода вы, вероятно, захотите использовать свой графический процессор. И C, и Fortran имеют много более или менее хорошо интегрированного интерфейса CUDA / OpenCL (а теперь и OpenACC).

Мой умеренно объективный ответ: если вы знаете оба языка одинаково хорошо / плохо, то я думаю, что Fortran быстрее, потому что мне легче писать параллельный / распределенный код на Fortran, чем на C. (как только вы поняли, что вы можете писать fortran в произвольной форме и не просто строгий код F77)

Вот второй ответ для тех, кто хочет проголосовать против меня, потому что им не нравится первый ответ: оба языка имеют функции, необходимые для написания высокопроизводительного кода. Таким образом, это зависит от алгоритма, который вы реализуете (интенсивное использование ЦП? Интенсивное использование памяти?), Оборудования (один ЦП? Многоядерный? Распределенный суперкомпьютер? GPGPU? FPGA?), Ваших навыков и, в конечном итоге, самого компилятора. И C, и Fortran имеют отличный компилятор. (я серьезно поражен тем, насколько продвинуты компиляторы Fortran, но и компиляторы C - тоже).

PS: я рад, что вы специально исключили библиотеки, потому что я могу сказать много плохого о библиотеках графического интерфейса Fortran. :)

Быстро и просто: Оба одинаково быстры, но Фортран проще. Что действительно быстрее в конечном итоге зависит от алгоритма, но в любом случае существенной разницы в скорости нет. Это то, что я узнал на семинаре по Fortran в центре высокопроизводительных вычислений в Штутгарде, Германия, в 2015 году. Я работаю как с Fortran, так и с C, и разделяю это мнение.

Объяснение:

C был разработан для написания операционных систем. Следовательно, у него больше свободы, чем требуется для написания высокопроизводительного кода. В общем, это не проблема, но если не программировать внимательно, можно легко замедлить код.

Фортран был разработан для научного программирования. По этой причине он поддерживает синтаксис быстрого написания кода, так как это основная цель Fortran. В отличие от общественного мнения, Фортран не является устаревшим языком программирования. Его последний стандарт - 2010, и новые компиляторы публикуются на регулярной основе, поскольку большая часть высокопроизводительного кода написана на Фортране. Fortran также поддерживает современные функции в виде директив компилятора (в прагмах C).

Пример:Мы хотим предоставить большую структуру в качестве входного аргумента функции (fortran: подпрограмма). Внутри функции аргумент не изменяется.

C поддерживает как вызов по ссылке, так и вызов по значению, что является удобной функцией. В нашем случае программист может случайно использовать вызов по значению. Это значительно замедляет работу, поскольку сначала необходимо скопировать структуру в память.

Fortran работает только с вызовом по ссылке, что заставляет программиста копировать структуру вручную, если он действительно хочет вызвать операцию по значению. В нашем случае fortran будет автоматически работать так же быстро, как версия C с вызовом по ссылке.

Используя современные стандарты и компилятор, нет!

Некоторые из присутствующих здесь предположили, что FORTRAN быстрее, потому что компилятору не нужно беспокоиться о наложении имен (и, следовательно, он может делать больше предположений во время оптимизации). Однако это было решено в C со времен стандарта C99 (я думаю) с включением ключевого слова restrict. Это в основном сообщает компилятору, что в заданной области указатель не имеет псевдонима. Кроме того, C обеспечивает правильную арифметику указателей, где такие вещи, как псевдонимы, могут быть очень полезны с точки зрения производительности и распределения ресурсов. Хотя я думаю, что более поздняя версия FORTRAN позволяет использовать «правильные» указатели.

Для современных реализаций C вообще превосходит FORTRAN (хотя он тоже очень быстр).

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

Обновлено:

Справедливой критикой этого, кажется, является то, что бенчмаркинг может быть необъективным. Вот еще один источник (относительно C), который помещает результат в более контекст:

http://julialang.org/benchmarks/

Вы можете видеть, что C обычно превосходит Fortran в большинстве случаев (снова см. Критические замечания ниже, которые применимы и здесь); как утверждали другие, бенчмаркинг - это неточная наука, которую можно легко загрузить, отдав предпочтение одному языку над другими. Но это действительно добавляет контекста, что Fortran и C имеют одинаковую производительность.

Fortran может очень удобно обрабатывать массивы, особенно многомерные массивы. Нарезка элементов многомерного массива в Фортране может быть намного проще, чем в C / C++. В C++ теперь есть библиотеки, которые могут выполнять эту работу, такие как Boost или Eigen, но они, в конце концов, являются внешними библиотеками. В Фортране эти функции являются внутренними.

Будет ли Fortran быстрее или удобнее для разработки, во многом зависит от работы, которую вам нужно завершить. Как человек, занимающийся научными вычислениями в области геофизики, я большую часть вычислений выполнял на Фортране (я имею в виду современный Фортран,> = F90).