Что такое FLOP/s и является ли это хорошим показателем производительности?

Question

Меня попросили измерить производительность программы на языке Фортран, которая решает дифференциальные уравнения в многопроцессорной системе.Мой работодатель настаивает, чтобы я измерял FLOP/s (плавающие операции в секунду) и сравнивал результаты с контрольными показателями (ЛИНПАК), но я не уверен, что это правильный путь, просто потому, что никто не может объяснить мне, что такое ФЛОП.

Я провел небольшое исследование того, что такое ФЛОП, и получил довольно противоречивые ответы.Один из самых популярных ответов, которые я получил, был: «1 FLOP = операция сложения и умножения».Это правда?Если да, то опять же, физически, что именно это означает?

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

Какими были бы другие эффективные способы измерения производительности в моем случае (краткое описание моего случая - это «код на Фортране, который снова и снова выполняет множество арифметических вычислений в течение нескольких дней на нескольких сотнях процессоров)?»

Answer 1

Это довольно приличный показатель производительности, если вы точно понимаете, что он измеряет.

FLOPS — это, как следует из названия, число операций с плавающей запятой в секунду. То, что представляет собой FLOP, может варьироваться в зависимости от процессора.(Некоторые процессоры могут выполнять сложение и умножение как одну операцию, другие, например, не могут).Это означает, что в качестве показателя производительности она довольно близка к аппаратному обеспечению, а это означает, что 1) вам нужно знать свое оборудование, чтобы вычислить идеальные FLOPS на данной архитектуре, и вы должны знать свой алгоритм и реализацию, чтобы выяснить, как из многих операций с плавающей запятой он на самом деле состоит.

В любом случае, это полезный инструмент для проверки того, насколько хорошо вы используете процессор.Если вы знаете теоретическую пиковую производительность ЦП в FLOPS, вы можете определить, насколько эффективно вы используете модули ЦП с плавающей запятой, которые часто являются одними из самых сложных в эффективном использовании.Программа, которая выполняет 30% FLOPS, на которые способен процессор, имеет возможности для оптимизации.Тот, который работает на 70%, вероятно, не станет намного более эффективным, если вы не измените базовый алгоритм.Для таких сложных математических алгоритмов, как ваш, это практически стандартный способ измерения производительности.Вы можете просто измерить, сколько времени требуется для запуска программы, но это сильно зависит от процессора.Но если ваша программа использует 50% ЦП (относительно пикового количества FLOPS), это несколько более постоянное значение (оно все равно будет различаться в зависимости от радикально разных архитектур ЦП, но оно намного более согласовано, чем время выполнения).

Но знать, что «Мой процессор способен работать с производительностью X гигафлопс, а на самом деле я достигаю пропускной способности, скажем, только в 20% от этой» — это очень ценную информацию в высокопроизводительном программном обеспечении.Это означает, что что-то другой чем операции с плавающей запятой сдерживают вас и мешают эффективно работать модулям FP.А поскольку на блоки FP приходится основная часть работы, это означает, что в вашем программном обеспечении возникла проблема.

Легко измерить «Моя программа выполняется за X минут», и если вы чувствуете, что это неприемлемо, то, конечно, вы можете сказать: «Интересно, смогу ли я сократить это на 30%», но вы этого не сделаете. знать если это возможно, если вы не определите, сколько именно работы выполняется и на что именно способен процессор в пиковую нагрузку.Сколько времени вы готовы потратить на оптимизацию, если даже не знаете, способен ли ЦП выполнять больше инструкций в секунду?

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

Зачем вам нужны другие способы измерения производительности?Что плохого в том, чтобы просто подсчитать количество FLOPS, как просил вас ваш начальник?;)

Answer 2

Я просто хотел бы добавить пару более тонких моментов:

• разделение особенный.Поскольку большинство процессоров могут выполнять сложение, сравнение или умножение за один цикл, все они считаются за один флоп.Но деление всегда занимает больше времени.Насколько дольше зависит от процессора, но в сообществе HPC де-факто существует своего рода стандарт, согласно которому одно деление считается за 4 флопа.

• Если процессор имеет слитое умножение-сложение инструкция, выполняющая умножение и сложение в одной инструкции (обычно A += B * C), которая считается за две операции.

• Всегда будьте осторожны, различая одинарной точности проваливается и флопы двойной точности.Процессор, способный обрабатывать такое количество гигафлопс одинарной точности, может быть способен обрабатывать лишь небольшую часть этого количества гигафлопс двойной точности.Процессоры AMD Athlon и Phenom обычно могут выполнять вдвое меньше операций двойной точности, чем одинарную.Процессоры ATI Firestream обычно могут выполнять в 1/5 раза больше флопов двойной точности, чем одинарной точности.Если кто-то пытается продать вам процессор или пакет программного обеспечения, а он просто цитирует провалы, не говоря, что именно, вам следует позвонить ему по этому поводу.

• Термины мегафлоп, гигафлоп, терафлоп и т. д.находятся в общем пользовании.Они относятся к факторам 1000, не 1024.Например, 1 мегафлоп = 1 000 000 флопс/сек, а не 1 048 576.Как и в случае с размерами дисков, здесь существует некоторая путаница.

Answer 3

" сравните результаты с контрольными показателями " и что делать?

FLOPS означает, что вам нужно

1) FLOPs за какую-то единицу работы.

2) время для этой единицы работы.

Допустим, у вас есть некоторый входной файл, который выполняет 1000 итераций в некотором цикле. Цикл - это удобная единица работы. Он исполняется 1000 раз. Это займет час.

Цикл имеет несколько сложений и умножений, несколько делений и квадратный корень. Вы можете рассчитывать добавляет, умножает и делит. Вы можете посчитать это в источнике, ища +, * и /. Вы можете найти выходные данные на языке ассемблера от компилятора и посчитать их там. Вы можете получить разные номера. Какой из них прав? Спроси своего босса.

Вы можете сосчитать квадратные корни, но вы не знаете, что они действительно делают с точки зрения умножения и сложения. Таким образом, вам нужно будет сделать что-то вроде теста умножения на квадратный корень, чтобы понять, сколько времени занимает квадратный корень.

Теперь вы знаете FLOPS в вашем цикле. И вы знаете время, чтобы запустить его 1000 раз. Вы знаете, FLOPS в секунду.

Затем вы смотрите на LINPACK и обнаруживаете, что вы медленнее. Что теперь? Ваша программа не LINPACK, и она медленнее, чем LINPACK. Скорее всего, ваш код будет работать медленнее. Если ваш код не был написан и оптимизирован за такое же количество лет как LINPACK, вы будете медленнее.

Вот другая часть. Ваш процессор имеет определенный рейтинг FLOPS против различных тестов. Ваш алгоритм не является одним из тех критериев, поэтому вы не соответствуете критериям. Это плохо? Или это очевидное следствие того, что он не является эталоном?

Каким будет ожидаемый результат?

Измерение по некоторой базе кодов производительности покажет вам, что ваш алгоритм не является алгоритмом тестирования. Это предрешенный вывод, что вы будете другими; обычно медленнее.

Очевидно, что результатом измерения по LINPACK будет: (а) вы отличаетесь и, следовательно, (б) вам необходимо оптимизировать.

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

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

LINPACK не имеет значения. Важна ваша база кода и изменения, которые вы вносите для повышения производительности.

Answer 4

Старый вопрос со старыми, хотя и популярными, ответами, которые, по моему мнению, не совсем хороши.

«FLOP» — это математическая операция с плавающей запятой.«ФЛОПС» может означать одно из двух:

• Простое множественное число слова «ФЛОП» (т.е.«операция Икс занимает 50 флопов»)
• А ставка FLOP в первом смысле (т.е.математических операций с плавающей запятой в секунду)

Если из контекста неясно, что именно имеется в виду, часто устраняют неоднозначность, записывая первое как «FLOP», а второе как «FLOP/s».

Флопы названы так, чтобы отличать их от других видов операций ЦП., такие как целочисленные математические операции, логические операции, побитовые операции, операции с памятью и операции ветвления, которые имеют разные затраты (читай: «занимают разную продолжительность времени»), связанные с ними.

Практика «подсчета FLOP» восходит к самым ранним дням научных вычислений, когда FLOP были, условно говоря, чрезвычайно дорогими и требовали много циклов процессора каждый.Например, математическому сопроцессору 80387 потребовалось около 300 тактов для одного умножения.Это было в то время, когда еще не было конвейерной обработки и до того, как пропасть между тактовой частотой процессора и скоростью памяти действительно открылась:Операции с памятью занимали всего один или два цикла, а ветвление («принятие решений») было столь же дешевым.Тогда, если бы вы могли исключить один FLOP в пользу дюжины обращений к памяти, вы получили бы выигрыш.Если бы вы могли исключить один ФЛОП в пользу дюжины ветвей, вы получили бы прибыль.Так, в прошлом имело смысл подсчитывать FLOP и не особо беспокоиться об обращениях к памяти и ветвях, поскольку FLOP сильно доминировали во времени выполнения. потому что они по отдельности были очень дорогими по сравнению с другими видами операций.

Совсем недавно ситуация изменилась.Флопы стали очень дешевыми — любой современный Intel основной может выполнять около двух FLOP за цикл (хотя деление остается относительно дорогим), а доступ к памяти и переходы сравнительно намного дороже:попадание в кеш L1 стоит примерно 3 или 4 цикла, выборка из основной памяти стоит 150–200.Учитывая эту инверсию, уже не тот случай, когда исключение FLOP в пользу доступа к памяти приведет к выигрышу;на самом деле это маловероятно.Точно так же зачастую дешевле «просто сделать» ФЛОП, даже если это избыточно, чем решать, делать это или нет.Это практически полная противоположность ситуации 25 лет назад.

К сожалению, практика слепого подсчета FLOP как абсолютного показателя качества алгоритмов сохранилась и после срока годности. Современные научные вычисления в большей степени связаны с управлением пропускной способностью памяти. — пытаясь сохранить исполнительные единицы, которые делать Флопы постоянно снабжаются данными — тогда речь идет об уменьшении количества Флопов.Ссылка на ЛИНПАК (который был по существу устаревшим ЛАПАК 20 лет назад) заставляет меня подозревать, что ваш работодатель, вероятно, придерживается очень старой школы и не усвоил тот факт, что установление ожиданий по производительности больше не является просто вопросом подсчета провалов.Решатель, который выполняет в два раза больше операций FLOP, все равно может быть в двадцать раз быстрее другого, если у него гораздо более благоприятный шаблон доступа к памяти и расположение данных.

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

Возможно, лучший способ осмысления ожиданий и оценки результатов работы заключается в так называемом методе модель линии крыши, который далек от совершенства, но имеет то преимущество, что заставляет вас одновременно подумайте о компромиссе между проблемами с плавающей запятой и пропускной способностью памяти, предоставляя более информативную и содержательную «2D-картину», которая позволяет сравнивать измерения производительности и ожидаемые результаты.

Это стоит посмотреть.

Answer 5

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

Answer 6

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

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

• Большую часть времени он находится в процессе вычисления производной и/или якобиана.Большая часть этого времени может уйти на вызовы математических функций, таких как exp(), log(), и sqrt().Часто они повторяются с одинаковыми аргументами и их можно запомнить.(Огромное ускорение.)

• Большая часть времени тратится на вычисление производных слишком много раз, потому что допуски интегрирования более жесткие, чем необходимо.(Быстрее)

• Если используется неявный алгоритм интегрирования (например, DLSODE Gear), поскольку уравнения считаются жесткими, скорее всего, это не так, и можно использовать что-то вроде Рунге-Кутты.(ДВЕРК).(Еще быстрее)

• Возможно, можно использовать алгоритм матричной экспоненты, если модель линейная (DGPADM).Это большой выигрыш как с точки зрения производительности, так и точности, и он невосприимчив к жесткости.(Намного быстрее)

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

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

Итак, вернемся к флопам.Вы могли бы попытаться максимизировать FLOPs / second, но это также может быть гораздо полезнее минимизировать FLOPs / run, путем оптимизации на всех уровнях стека.В любом случае, просто измерение они вам почти ничего не говорят.

Answer 7

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

Что касается FLOP, то это означает «операции с плавающей запятой в секунду»; - см. определение в Википедии.

Answer 8

Я не думаю, что измерение FLOPS будет очень полезным.

Количество достигнутых FLOPS скажет вам, насколько ваш алгоритм удерживает процессор, но не скажет, насколько хорошо работает ваш алгоритм.

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

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

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