О Терафлопсах

Для истинных ценителей:

================================================================================
HPL-GPU 1.1.0  --  High-Performance Linpack benchmark  --   2010
Written by D. Rohr, M. Kretz and M. Bach,  Frankfurt Institute for Advanced Studies
Based on:
HPLinpack 2.0  --  High-Performance Linpack benchmark  --   September 10, 2008
Written by A. Petitet and R. Clint Whaley,  Innovative Computing Laboratory, UTK
Modified by Piotr Luszczek, Innovative Computing Laboratory, UTK
Modified by Julien Langou, University of Colorado Denver
================================================================================
...skip...
================================================================================
T/V                N    NB     P     Q               Time    CPU          Gflops
--------------------------------------------------------------------------------
WC06L2C64      122880  2048     1     1            1006.60 8742.71       1.229e+03
Avg. matri size per node: 112.50 GiB
--------------------------------------------------------------------------------
||Ax-b||_oo/(eps*(||A||_oo*||x||_oo+||b||_oo)*N)=        0.0002429 ...... PASSED
Это один узел кластера, а не кластер; не Nvidia; прочие подробности я пока раскрывать не уполномочен. Через месяцок.

Но штука получается забавная. И хочется надеяться, что цифирка в правой колонке еще далека от окончательной.

P.S. Троллинг: в тред призывается поисковая команда Яндекса, получившая на 400 узлах в 600 раз меньше. Правда два года назад.

P.P.S. Это, естественно, двойная точность.

Comments

Больше терафлопса? 4-8 16-ядерников.

Ну все-таки тег gpgpu есть у сообщения :)

На CPU оценка более-менее правильная,да: 3 гигагерца x 4 flop/clock - это 12 гигафлопс пиковой на ядро, реально на HPL получить процентов 75 т.е. 9glops, 136 ядер.
В реальности же получается даже не 75% от теоретической пиковой производительности, а ~75% от DGEMM. Это на CPU. На gpgpu похуже пока.

Ну не надо так пессимизировать. На хорошем интерконнекте 83-85% все-таки на CPU получается.

Ну я совсем не специалист, просто жизнь заставила, что вижу, то и пою.

А вижу я на CPU следующее. Без всяких кластеров, в коих я тем более не специалист, просто single node:
- Corei7 3Ghz 4 ядра x 4 flops/clock x 3 = 48Gflops peak, реальных 36 на HPL (GotoBLAS). 75%
- 2x12 core opteron, 220 пиковой, 170 реальных. 77%

Правда про оптерон я знаю почти точно, а про i7 подозреваю, что они уперты в memory bandwidth (уменьшаем число задействованных ядер и производительность почти не падает).

Если в вместо GotoBLAS взять MKL, результаты будут получше, это что сходу. Дальше - надо крутить всякие параметры самого HPL, так тяжело обсуждать.

На i7 (не AVX) я пробовал - и получил примерно столько же, не кардинальная разница, может процентов 5.

Но если смотреть на теги/рубрику данного сообщения, то становится понятным, что MKL нерелевантна, основной счет все едино не на CPU.

Да я понимаю, что MKL - CPU only. Это я к тому, что умельцы на CPU (тем более на одной машине) выжимают процентов до 90. Про GPU же тоже речь про умельцев идет.

А памяти надо много, да, тогда будет лучше.

В практическом смысле интересует следующий вопрос, если вы сталкивались:

- если мы "накрутили параметры HPL" для задачи размера N (достаточно большого, пусть она 10-15 минут считается на имеющемся кластере)
- будут ли эти же параметры близки к оптимальным для 2*N, 3*N, 8*N?

В пределах одной ноды оно не вполне так и для каждого размера приходится что-то переподбирать, но по счастью самая большая влезающая задача (122к) считается где-то минут 15, за сутки вариантов перебрать можно прилично.

10-15 минут все же маловато, на мой взгляд. Там коммуникаций заметно. Вот если для часовой - то можно сказать, что будут близки и для 2*N, 3*N, сколько там памяти хватит. Но это так, навскидку, я линпак крутил, но все ж таки не очень глубоко. На кластере гораздо сильнее играет роль равномерность распределения нагрузки, поэтому если уж мы ее нормально распределили, то дальше все проще. Но ради единиц процентов все равно придется крутить отдельно.

В самых низах Top500 - один процент это мест 15. Несколько процентов того стоят.

А в верхах - престиж. Вон японцы на K больше 90 выжали - все ахают.

Верхи мне не светят (в смысле личной практики), я не HPC-специалист, просто мимо проходил.

А вот 40-80 машин, вроде той, что поминается в самом моем посте - вполне могут оказаться на пути (с infiniband, вестимо). А с ними попасть в низы топ500 вполне реально.

Дело у меня скорее в другом: эффективность заметно растет с ростом задачи, но на i7 у меня памяти мало (всего 12Gb), а на оптероне ее хоть и много, но задачи больше чем ~40k пускать считаться на CPU скучно, слишком уж долго.

Но намек понял, задачу размером ~120k на оптероне как-нибудь запущу, чисто из интереса. Это часа на два-три...

А, действительно, это же Linpack, а не перемножение матриц, стормозил :)

На перемножении матриц та же система - 2.2 терафлопса.

Ну и нормально. Современный GPU.

Это двойная точность, не одинарная.

О, другое дело. Тогда 2x6990, ибо у AMD MULADD_64 в 4 раза "медленнее", чем MULADD :)

Браво!

Угадал с трех раз :)

Судя по всему это Intel MIC и наверняка в одинарной точности.

Точность - двойная.

А интеловского в этих машинах - только контроллер Ethernet

Не обратил внимания, что это Франкфуртовский университет.
А сколько в процентах получается от теоретической???

Порядка 75% для двух GPU, порядка 50% - для четырех.

"порядка" - потому что неясно, как учитывать в Rpeak те CPU cores, которые занимаются вводом-выводом. Можно формально (и тогда Rpeak будет на 100-110Gflops больше), а можно "сделать скидку на занятость" и тогда поменьше.

Rpeak одного GPU - 600 gflops, потому что они у нас на 750Mhz, а не на родных 830 (температурный режим....)

"получившая в 600 раз меньше" - не очень-то и хотелось :)

Тельняшку Расковалов рвал на груди, обещая порвать Ломоносова на тряпки?

Вы не обижайтесь лишнего, я просто в ППБ вбил слово HPlinpack и наткнулся на тот пост....

ну так и порвёт Ломоносова на тряпки. По суммарному IO bandwidth, например :) А с линпаком Ден погорячилсо - неподходящий алго там для слабого неравномерного интерконнекта. Вот если матрицу побольше и переписать всё, тогда можно и попробовать

Ну так да, он погорячилсо, а я докопался.

"Переписать все" - отличный аргумент, я впечатлен.

в смысле "отличный аргумент"? Это не аргумент вовсе, а констатация факта. Пользовательская задача звучит так: решить линейную систему Ax=b с плотной A. Если бы мы вдруг захотели её решить и соревноваться в скорости решения этого уравнения при заданной точности, то не смогли бы использовать код из линпака с пользой (мне так кажется по крайней мере). Метод неподходящий, MPI нам не нужен, у нас свой велосипед, что там остаётся? Код чтения матрицы из файла?

Все вы правильно говорите.

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

Думаю там не дураки сидят и по price/performance выгоднее инфинибэнд, тем более что не такой уж он и дорогой в последнее время. Я говорю, что на непредназначенном для этого железе можно получить больше чем 2Gflops-a с кластера для задачи Ax=b, а может и потягаться с самим ломоносовым по скорости решения этой задачи. Но придётся делать совсем другим способом. Этот способ не будет выгоден по price/performance, но в яндексе настолько много компов, что даже неэффективный метод мог бы посоревноваться с ломоносовым на этой задаче (теоретически). Ok?

Каким способом извлекаются деньги из быстрой решалки Ax=b я не очень понимаю. Это ж статья на конференцию и всеобщая благодарность, а не фирма. Не продаются же, например, оптимизированные BLAS библиотеки?

Дело не только в цене (хотя и она кусается, если портов десятки тысяч). Там гигантские геморои с питанием и охлаждением, потому что быстрый и плотный (все эти чудовищные 4D-торы) интерконнект не растянуть по разным зданиям/залам.

Т.е. Ax=b не в плотном кластере а в (как сейчас модно говорить) облаке т.е. с миллисекундными задержками и гигабитными линками - это важная (для всего человечества) задача. Я не уверен что решаемая, впрочем.
Конечно, Rmax/Rpeak должен быть разумным, это не должны быть доли процента.

И более того, найдя подход к Ax=b, можно будет много еще на что замахнуться.

честно сказать, решать Ax=b с огромными плотными матрицами особо не нужно для задач мат. моделирования (численное решение дифуров). во-первых, конечные элементы и конечные разности дают разряженные матрицы, а во-вторых, решать уравнения точно (до double точности) почти никогда не нужно. а значит нам нужны эффективные итеративные методы. для них главные операции - умножение матрицы на вектор и применение прекондишинера имеют сложность n^2 и упираются в память, гигафлопсов особо не достичь.

а если уж хочется их решать. то нужно использовать специальные ускорители вроде ClearSpeed или FPGA, что эффективнее всего остального.

Судя по сайту ClearSpeed, они сейчас уже гордятся гигафлопсами на ватт (что тоже важно), а не просто гигафлопсами.

Даже для сложности N*log(N) (сортировка) получается выигрыш, хотя и непринципиальный (в первые разы). А если трансфер прятать в DMA, то принципиальный т.к. CPU разгружается.

Про конечные элементы/разности я по личному опыту сказать уже ничего не могу, в статьях пишут что "польза есть и преизрядная", но не на порядки, конечно. Порядки получаются только для синусов-косинусов-экспонент, по очевидным причинам.

А HPL - пузомерка, кто бы спорил.

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

http://blog.lexa.ru/2011/09/12/o_high_performance_linpack.html#comment-1...

во-первых, конечные элементы и конечные разности дают разряженные матрицы

зависит от задачи, но да, в большинстве случаев МКЭ это разряженные матрицы.

а во-вторых, решать уравнения точно (до double точности) почти никогда не нужно. а значит нам нужны эффективные итеративные метод
Эффективные итерационные методы типа CG, для получения приемлемой точности требуют double вычислений. CG отличается от простых методов тем, что у него есть "контекст", а именно есть большая разница как мы попали в точку x1 (например это первое приближение, или допустим на некотором большом шаге n/1000), и точность вычислений при CG определяет скорость сходимости.
Я пробовал решать решать систему МКЭ на GPU(не суть), с помощью CG (+ предобуславливатель Якоби) - так вот, на некоторых задачах single-precision вообще не сходилось к заданной точности, а на некоторых сходилось через количество итераций большее чем для double-precision.
Далее, нужно ещё учитывать то, что когда мы уменьшаем точность в матрице коэффициентов (допустим используем float вместо double) и используем float для вычислений, то мы не просто уменьшаем точность результата каждой итерации, а ещё и рассматриваем немного другую задачу.
упираются в память
да, верно - упирается в память. Причём для основных форматов разряженных матриц примерно половина bandwidth это коэффициенты матрицы, другая половина - индекс колонки для каждого коэфф. матрицы (то есть обычно uint32, и от точности вычислений не зависят) (ещё есть несколько других векторов, но они значительно меньше). То есть, при переходе float->double, необходимый bandwidth не увеличится в два раза, поэтому большого смысла в использовании float нет.

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

Уравнения получаемые в результате применения МКЭ, решаются не только с помощью итерационных методов, но и с помощью прямых.
И у каждых своя область применения. Прямые обычно применяют тогда, когда возможно (хватает памяти) - потому что получается намного быстрее чем итерационными. итерационные в остальных случаях (так как требуют гораздо меньше памяти. при итерационных методах, можно даже не хранить матрицу коэффициентов явно).
Так вот, прямые методы упираются обычно не в память, а во флопсы.
И у меня есть предположение, что коды используемые в hpl, отчасти могут быть использованы при решении разряженных слау прямыми методами.

для них главные операции - умножение матрицы на вектор и применение прекондишинера имеют сложность n^2 и упираются в память, гигафлопсов особо не достичь.
Ну вот вы сами себе и ответили - HPL решает Ax=b с плотными матрицами, чтобы как раз померятся flops'ами. Причём я бы сказал даже не flops'ами, а dgemm/s'ами. Делать тупо dgemm не интересно, мерить тупо flops'ы - тоже, поэтому и выбрали что-то более менее практическое.

Add new comment