Производительность железа, измеряемая во флопсах: что это и с чем едят?
Авторизуйтесь
Производительность железа, измеряемая во флопсах: что это и с чем едят?
Новейшее поколение игровых консолей достигло отметки в десяток терафлопс. Но что именно означает эта величина?
Производительность, измеряемая во FLOPS — это количество операций с плавающей запятой, которое может выполнить устройство за одну секунду. Отсюда и название: FLoating-point Operations Per Second. Сравнивать вычислительную мощность по флопсам намного проще, чем по тактовой частоте или чему-либо ещё.
График роста производительности суперкомпьютеров
Современная техника имеет колоссальную мощность. Поэтому, что бы не использовать большое количество нолей, к флопсам добавляют приставки СИ: гигафлопсы, терафлопсы, петафлопсы.
Краткий список железа и его производительности:
Самым слабым компьютером можно назвать Z3. Его вычислительная мощность составляет 2 флопса. Да, верно — он осиливает всего 2 операции в секунду. Но это простительно, ведь Z3 — первая работоспособная программируемая вычислительная машина, собранная ещё в 1940 г.
Вычислительная машина Z3
Cамым мощным компьютером на момент 2020 года можно назвать Фугаку — японский суперкомпьютер. Его заявленная мощность составляет 0,54 эксафлопса (для 64-разрядных вычислений). Это 540 000 терафлопс.
Источник
GFLOPS или по поводу производительности GPU
Практически все юзеры, которые понимают что-то в SoC вступают в кровопролитные споры о том, чей смартфон, процессор, GPU круче. Собственно, мощность GPU измеряют в FLOPS- специальной единице, которая показывает, сколько операций с плавающей запятой может выполнить GPU(и не только) в секунду. Кому интересно, прошу под кат!
Начнем с самого популярного GPU- Mali-400. Этот GPU завоевал немалую славу за счет своей производительности и энергопотребления. Одновременно мощный и экономный по отношению к заряду аккумулятора чип использовался во многих процессорах- от NovaThor U8500 до Exynos 4412. Существует множество разновидностей этого GPU, которые отличаются кол-вом ядер. Ниже привожу несколько сматфонов, в которые внедрен этот GPU и кол-во GFLOPS.
Samsung Galaxy Ace 2- Mali-400MP- 275MHz- 2.48Gflops
Samsung Galaxy S3- Mali-400MP4- 533MHz- 19.2Gflops
Довольно большая разница, не правда ли?
Также развожу миф о том, чем больше частота, тем мощнее чип
Mali-450MP4- 700MHz, который стоит в MT6592, и который, по заверениям нескольких пользователей Трешбокса должен побить даже ещё не вышедший Adreno 420. Результат- 41.8Gflops. Довольно большой шаг вперед по сравнению с Mali-400MP4, но Adreno 330- 450MHz набирает целых 129.6Gflops, что нереально много. Причем его частота ниже, чем на Mali-450MP4 на 250MHz. Для сравнения топовый PowerVR G6430- 450MHz, который стоит в IPhone 5S и IPad Air набирает 115.2Gflops.Самый мощный Mali-628MP6- 533MHz, который стоит в Octa версии Samsung Galaxy Note 3 набирает 102.4Gflops.
Также не стоит забывать Tegra 4 и Tegra 4i. GeForce ULP x72, который стоит в Tegra 4 набирает 96.8Gflops, а его LTE-брат с GeForce ULP x60- 79.2
Но тут происходит самое интересное, ведь Adreno 330 имеет и 550MHz версию(которую в скором будущем можно будет получить при помощи кастомных ядер) и эта самая разогнанная версия набирает целых 158.4Gflops! Это рекорд.
Давайте посмотрим и на более старые GPU, такие как Adreno 320, Adreno 225, GeForce ULP x12 и PowerVR SGX544MP3 и SGX554MP4, также не стоит забывать и о простом SGX544MP, который стоит в сверхпопулярном чипе MT6589.
Также, давайте рассмотрим видео процессоры Adreno 203, Adreno 205, Adreno 200, Adreno 220 и Adreno 305.Первые 4 видео процессора набирают следующие оценки: Adreno 200- 3.92Gflops при частоте 245MHz, Adreno 203- 7.84Gflops при той-же частоте 245MHz. Как видим: двукратный результат при одинаковой частоте.
Adreno 205- продолжение 203-го. Он набирает 8.5Gflops, что не очень много, но следующий GPU, под названием Adreno 220 ломает стереотипы не самых топовых GPU: невероятные 18Gflops- уровень Mali-400MP4 533MHz, который стоит в топовом Samsung Galaxy S3. Теперь рассмотрим Adreno 305, который является упрощённой версией Adreno 320. Данный GPU стоит в таких процессорах, как Snapdragon S4 Plus и Snapdragon 400. Так вот, данный ускоритель набирает 21.6Gflops при частоте 450MHz.
Adreno 320 разделяется на два разряда: который стоит в S4 Pro, и который стоит в Snapdragon 600. Отличаются они кол-вом блоков: если у S4 Pro версии их 64, то у 600 версии их 96. Adreno 320 S4 Pro набирает 57Gflops, а его S600 версия целых 97.2 при частоте 450MHz. Это даже больше, чем GeForce ULP x72, поэтому в Snapdragon 600 1.9GHz более мощный GPU, чем в Tegra 4. Шокирующий результат.
Давайте посмотрим на Adreno 225. При частоте в 400MHz он набирает 25.6Gflops. Для сравнения GeForce ULP x12, который стоит в Tegra 3 набирает 12.5Gflops при частоте 520MHz. Adreno 225 мощнее чем GeForce ULP x12… Мда… Но если по делу, то у GeForce ULP x12 производительность на уровне… На 4.5Gflops ниже, чем на Adreno 220…
Теперь перейдем к PowerVR SGX544MP3, который стоит в Exynos 5410 или, проще говоря в Samsung Galaxy S4. Его производительность составляет 51.1Gflops. Не самый мощный. Более топовый SGX554MP4, который послужил игровой основой для IPad 4 выдает 76.8Gflops. Значительно больше.
Но как только я узнал производительность SGX544MP, который стоит в MT6589 и MT6589T я… неважно. У MT6589 версия с частотой 286MHz. Он выдает всего 9.2Gflops. Это очень мало, но всеравно больше, чем у его младшего брата MT6589M. У него граф. ускоритель работает на частоте всего 156MHz. Честно говоря мне не хочется говорить о этом процессоре, но придется. Так вот, он выдает всего 4.9Gflops. Это немногим лучше, чем на Adreno 200. Турбированный MT6589T владеет ускорителем с частотой 357MHz и это дает ему 11.4Gflops.
А теперь по поводу консолей. Многими любимый PSP выдает всего 2.6Gflops. Вы помните невероятную графику PSP игр? А то, как они плавно шли на нем? Adreno 330 более чем в 50 раз мощнее, чем PSP. Но 50-кратного прироста не ощущается. PSVita- это серьезное развитие железа. Он обладает PowerVR SGX543MP4+ и это дает внушительные 51.2Gflops.
А теперь по поводу PS и Xbox. PS3 обладает производительностью в 228.8Gflops и я верю, что следующее поколение GPU будет мощнее, чем любимая многими приставка, но до уровня PS4, который набирает 1840Gflops еще, как раком до Китая. Кстати, сверхмощная видеокарта Nvidia GeForce GTX Titan набирает 4500Gflops, а новый GTX 780Ti примерно 4800Gflops. До компа, как до Луны 😀
О, забыл о видео ускорителе Vivante GC6400, который работает на частоте 800MHz. Этот видеоускоритель- единственный конкурент адскому Adreno 330: его производительность составляет 128. Gflops, что всего на 1.6Gflops меньше, чем у Adreno 330, но мы знаем, что разработчики не сильно хотят оптимизировать игры под этот редкий ускоритель. Я, например, не знаю ни одного устройства с данным ускорителем. Кто знает: напишите, пожалуйста, в комментариях
Если составить рейтинг мобильных GPU, то получается следующий список:
Но не стоит забывать об энергопотреблении, ведь если судить именно по нему, то рейтинг немного поменяется 🙂
Источник
Как и зачем мерить FLOPSы
Как известно, FLOPS – это единица измерения вычислительной мощности компьютеров в (попугаях) операциях с плавающей точкой, которой часто пользуются, чтобы померить у кого больше. Особенно важно померяться FLOPS’ами в мире Top500 суперкомпьютеров, чтобы выяснить, кто же среди них самый-самый. Однако, предмет измерения должен иметь хоть какое-нибудь применение на практике, иначе какой смысл его замерять и сравнивать. Поэтому для выяснения возможностей супер- и просто компьютеров существуют чуть более приближенные к реальным вычислительным задачам бенчмарки, например, SPEC: SPECint и SPECfp. И, тем не менее, FLOPS активно используется в оценках производительности и публикуется в отчетах. Для его измерения давно уже использовали тест Linpack, а сейчас применяют открытый стандартный бенчмарк из LAPACK. Что эти измерения дают разработчикам высокопроизводительных и научных приложений? Можно ли легко оценить производительность реализации своего алгоритма в FLOPSaх? Будут ли измерения и сравнения корректными? Обо всем этом мы поговорим ниже.
Давайте сначала немного разберемся с терминами и определениями. Итак, FLOPS – это количество вычислительных операций или инструкций, выполняемых над операндами с плавающей точкой (FP) в секунду. Здесь используется слово «вычислительных», так как микропроцессор умеет выполнять и другие инструкции с такими операндами, например, загрузку из памяти. Такие операции не несут полезной вычислительной нагрузки и поэтому не учитываются.
Значение FLOPS, опубликованное для конкретной системы, – это характеристика прежде всего самого компьютера, а не программы. Ее можно получить двумя способами – теоретическим и практическим. Теоретически мы знаем сколько микропроцессоров в системе и сколько исполняемых устройств с плавающей точкой в каждом процессоре. Все они могут работать одновременно и начинать работу над следующей инструкцией в конвеере каждый цикл. Поэтому для подсчета теоретического максимума для данной системы нам нужно только перемножить все эти величины с частотой процессора – получим количество FP операций в секунду. Все просто, но такими оценками пользуются, разве что заявляя в прессе о будущих планах по построению суперкомпьютера.
Практическое измерение заключается в запуске бенчмарка Linpack. Бенчмарк осуществляет операцию умножения матрицы на матрицу несколько десятков раз и вычисляет усредненное значение времени выполнения теста. Так как количество FP операций в имплементации алгоритма известно заранее, то разделив одно значение на другое, получим искомое FLOPS. Библиотека Intel MKL (Math Kernel Library) содержит пакет LAPAСK, — пакет библиотек для решения задач линейной алгебры. Бенчмарк построен на основе этого пакета. Cчитается, что его эффективность находится на уровне 90% от теоретически возможной, что позволяет бенчмарку считаться «эталонным измерением». Отдельно Intel Optimized LINPACK Benchmark для Windows, Linux и MacOS можно качать здесь, либо взять в директории composerxe/mkl/benchmarks, если у вас установлена Intel Parallel Studio XE.
Очевидно, что разработчики высокопроизводительных приложений хотели бы оценить эффективность имплементации своих алгоритмов, используя показатель FLOPS, но уже померянный для своего приложения. Сравнение измеренного FLOPS с «эталонным» дает представление о том, насколько далека производительность их алгоритма от идеальной и каков теоретический потенциал ее улучшения. Для этого всего-навсего нужно знать минимальное количество FP операций, требуемое для выполнения алгоритма, и точно измерить время выполнения программы (ну или ее части, выполняющей оцениваемый алгоритм). Такие результаты, наряду с измерениями характеристик шины памяти, нужны для того, чтобы понять, где реализация алгоритма упирается в возможности аппаратной системы и что является лимитирующим фактором: пропускная способность памяти, задержки передачи данных, производительность алгоритма, либо системы.
Ну а теперь давайте покопаемся в деталях, в которых, как известно, все зло. У нас есть три оценки/измерения FLOPS: теоретическая, бенчмарк и программа. Рассмотрим особенности вычисления FLOPS для каждого случая.
Теоретическая оценка FLOPS для системы
Чтобы понять, как подсчитывается количество одновременных операций в процессоре, давайте взглянем на устройство блока out-of-order в конвеере процессора Intel Sandy Bridge.
Здесь у нас 6 портов к вычислительным устройствам, при этом, за один цикл (или такт процессора) диспетчером может быть назначено на выполнение до 6 микроопераций: 3 операции с памятью и 3 вычислительные. Одновременно могут выполняться одна операция умножения (MUL ) и одна сложения (ADD ), как в блоках x87 FP, так и в SSE, либо AVX. С учетом ширины SIMD регистров 256 бит мы может получить следующие результаты:
8 MUL (32-bit) и 8 ADD (32-bit): 16 SP FLOP/cycle, то есть 16 операций с плавающей точкой одинарной точности за один такт.
4 MUL (64-bit) и 4 ADD (64-bit): 8 DP FLOP/cycle, то есть 8 операций с плавающей точкой двойной точности за один такт.
Теоретическое пиковое значение FLOPS для доступного мне 1-сокетного Xeon E3-1275 (4 cores @ 3.574GHz) составляет:
16 (FLOP/cycle)*4*3.574 (Gcycles/sec)= 228 GFLOPS SP
8 (FLOP/cycle)*4*3.574 (Gcycles/sec)= 114 GFLOPS DP
Запуск бенчмарка Linpack
Запускам бенчмарк из пакета Intel MKL на системе и получаем следующие результаты (порезано для удобства просмотра):
Здесь нужно сказать, как именно учитываются FP операции в бенчмарке. Как уже упоминалось, тест заранее «знает» количество операций MUL и ADD, которые необходимы для перемножения матриц. В упрощенном представлении: производится решение системы линейных уравнений Ax=b (несколько тысяч штук) путем перемножения плотных матриц действительных чисел (real8) размером MxK, а количество операций сложения и умножения, необходимых для реализации алгоритма, считается (для симметричной матрицы) Nflop = 2*(M^3)+(M^2). Вычисления производятся для чисел с двойной точностью, как и для большинства бенчмарков. Сколько операций с плавающей точкой действительно выполняется в реализации алгоритма, пользователей не волнует, хотя они догадываются, что больше. Это связано с тем, что выполняется декомпозиция матриц по блокам и преобразование (факторизация) для достижения максимальной производительности алгоритма на вычислительной платформе. То есть нам нужно запомнить, что на самом деле значение физических FLOPS занижено за счет неучитывания лишних операций преобразования и вспомогательных операций типа сдвигов.
Оценка FLOPS программы
Чтобы исследовать соизмеримые результаты, в качестве нашего высокопроизводительного приложения будем использовать пример перемножения матриц, сделанный «своими руками», то есть без помощи математических гуру из команды разработчиков MKL Performance Library. Пример реализации перемножения матриц, написанный на языке С, можно найти в директории Samples пакета Intel VTune Amplifier XE. Воспользуемся формулой Nflop=2*(M^3) для подсчета FP операций (исходя из базового алгоритма перемножения матриц) и померим время выполнения перемножения для случая алгоритма multiply3 при размере симметричных матриц M=4096. Для того, чтобы получить эффективный код, используем опции оптимизации –O3 (агрессивная оптимизация циклов) и –xavx (использовать инструкции AVX) С-компилятора Intel для того, чтобы сгенерировались векторные SIMD-инструкции для исполнительных устройств AVX. Компилятор нам поможет узнать, векторизовался ли цикл перемножения матрицы. Для этого укажем опцию –vec-report3. В результатах компиляции видим сообщения оптимизатора: «LOOP WAS VECTORIZED» напротив строки с телом внутреннего цикла в файле multiply.c.
На всякий случай проверим, какие инструкции сгенерированы компилятором для цикла перемножения.
$icl –g –O3 –xavx –S
По тэгу __tag_value_multiply3 ищем нужный цикл — инструкции правильные.
$vi muliply3.s 
Результат выполнения программы (
7 секунд) 
нам дает следующее значение FLOPS = 2*4096*4096*4096/7[s] = 19.6 GFLOPS
Результат, конечно, очень далек от того, что получается в Linpack, что объясняется исключительно квалификционной пропастью между автором статьи и разработчиками библиотеки MKL.
Ну, а теперь дессерт! Собственно то, ради чего я затеял свое исследование этой, вроде бы скучной и давно избитой, темы. Новый метод измерения FLOPS.
Измерение FLOPS программы
Существуют задачи в линейной алгебре, программную имплементацию решения которых очень сложно оценить в количестве FP операций, в том смысле, что нахождение такой оценки само является нетривиальной математической задачей. И тут мы, что называется, приехали. Как считать FLOPS для программы? Есть два пути, оба экспериментальных: трудный, дающий точный результат, и легкий, но обеспечивающий приблизительную оценку. В первом случае нам придется взять некую базовую программную имплементацию решения задачи, скомпилировать ее в ассемблерные инструкции и, выполнив их на симуляторе процессора, посчитать количество FP операций. Звучит так, что резко хочется пойти легким, но недостоверным путем. Тем более, что если ветвление исполнения задачи будет зависеть от входных данных, то вся точность оценки сразу поставится под сомнение.
Идея легкого пути состоит в следующем. Почему бы не спросить сам процессор, сколько он выполнил FP инструкций. Процессорный конвеер, конечно же, об этом не ведает. Зато у нас есть счетчики производительности (PMU – вот тут про них интересно), которые умеют считать, сколько микроопераций было выполнено на том или ином вычислительном блоке. С такими счетчиками умеет работать VTune Amplifier XE.
Несмотря на то, что VTune имеет множество встроенных профилей, специального профиля для измерения FLOPS у него пока нет. Но никто не мешает нам создать наш собственный пользовательский профиль за 30 секунд. Не утруждая вас основами работы с интерфейсом VTune (их можно изучить в прилагающимся к нему Getting Started Tutorial), сразу опишу процесс создания профиля и сбора данных.
Далее мы просто подсчитываем значения FLOPS по формулам. Данные у нас были собраны для всех процессоров, поэтому умножение на их количество здесь не требуется. Операции данными двойной точности выполняются одновременно над четырмя 64-битными DP операндами в 256-битном регистре, поэтому умножаем на коэффициент 4. Данные с одинарной точностью, соответственно, умножаем на 8. В последней формуле не умножаем количество инструкций на коэффициент, так как операции сопроцессора x87 выполняются только со скалярными величинами. Если в программе выполняется несколько разных типов FP операций, то их количество, умноженное на коэффициенты, суммируется для получения результирующего FLOPS.
FLOPS = 4 * SIMD_FP_256.PACKED_DOUBLE / Elapsed Time
FLOPS = 8 * SIMD_FP_256.PACKED_SINGLE / Elapsed Time
FLOPS = (FP_COMP_OPS_EXE.x87) / Elapsed Time
В нашей программе выполнялись только AVX инструкции, поэтому в результатах есть значение только одного счетчика SIMD_FP_256.PACKED_DOUBLE.
Удостоверимся, что данные события собраны для нашего цикла в функции multiply3 (переключившись в Source View):
FLOPS = 4 *34.6Gops/7s = 19.7 GFlops
Значение вполне соответствует оценочному, подсчитанному в предыдущем пункте. Поэтому с достаточной долей точности можно говорить о том, что результаты оценочного метода и измерительного совпадают. Однако, существуют случаи, когда они могут не совпадать. При определенном интересе читателей, я могу заняться их исследованием и рассказать, как использовать более сложные и точные методы. А взамен очень хочется услышать о ваших случаях, когда вам требуется измерение FLOPS в программах.
Заключение
FLOPS – единица измерения производительности вычислительных систем, которая характеризует максимальную вычислительную мощность самой системы для операций с плавающей точкой. FLOPS может быть заявлена как теоретическая, для еще не существующих систем, так и измерена с помощью бенчмарков. Разработчики высокопроизводительных программ, в частности, решателей систем линейных дифференциальных уравнений, оценивают производительность реализации своих алгоритмов в том числе и по значению FLOPS программы, вычисленному с помощью теоретически/эмпирически известного количества FP операций, необходимых для выполнения алгоритма, и измеренному времени выполнения теста. Для случаев, когда сложность алгоритма не позволяет оценить количество FP операций алгоритма, их можно измерить с помощью счетчиков производительности, встроенных в микропроцессоры Intel.
Источник
Сравнение производительности современных смартфонов и компьютеров
Ни для кого не секрет, что за последние 10 лет телефоны сделали качественный скачок — если тогда они воспринимались в основном как звонилки, с крайне урезанным браузером и почти без возможности проигрывать видео, то сейчас это полноценные мультимедийные устройства с нормальными браузерами и плеерами, пакетом MS Office, играми, оснащенные камерами, способными снимать 4К видео — в общем, казалось бы, это полноценный ПК в кармане.
Это же мнение активно развивают и компании-производители: Apple продвигает iPad как замену ПК, Microsoft и Samsung представили док-станции, с помощью которых можно превратить смартфон в рабочее место. И поэтому у многих может сложиться впечатление, что по производительности смартфоны уже ничуть не хуже ПК (ну или хотя бы ноутбуков). Однако, забегая вперед — это далеко не так.
Разумеется, возникает вопрос — как сравнить производительность смартфонов, построенных на ARM-процессорах, и ПК, построенных на x86? Конечно, есть кроссплатформенные тесты типа GeekBench, однако их проблема в том, что их результаты крайне сильно зависят от оптимизации бенчмарка под ту или иную архитектуру или даже процессор — к примеру, GeekBench не видит кэш L3 у процессоров Apple, а ведь он достаточно серьезно влияет на скорость вычисления. Поэтому нам нужен бенчмарк, который использует «понятные» всем процессорам команды, которые никак не зависят от системы — и на эту роль хорошо подходит Linpack, который меряет FLOPS.
Что же такое FLOPS? Это единица измерения производительности устройства, показывающая, сколько операций с плавающей запятой в секунду оно может сделать. Операции с плавающей запятой происходят «внутри» процессора и никак не зависят от системы, а только от быстродействия самого процессора. И второй плюс — в отличие от высокоуровневых бенчмарков, тестирующих отдельно процессор и отдельно видеокарту, никто не мешает вычислить производительность и того, и другого во FLOPS.
Увы, нормального Linpack под iOS я не нашел (есть один, но он не поддерживает х64-вычисления, что, разумеется, скажется на производительности). А вот под Android он есть, и поддерживает х64 — можно его бесплатно скачать в Google Play. Для тестов был взят практически топовый по современным меркам Snapdragon 820, и его результат — порядка 2.7 GFLOPS: 
Тут, разумеется, возникает вопрос — это много или мало? Увы — это мало: к примеру, Intel Core i3-7100U, низковольтный современный процессор от Intel, набирает порядка 40 GFLOPS. Сравнимый с Snapdragon 820 результат (3.2 GFLOPS) набрал Pentium 4 на 3.4 ГГц:
То есть топовые смартфоны имеют тот же уровень производительности, что и топовые ПК 2004-2005 годов. Отсюда опять же возникает вопрос: почему на таком слабом по современным меркам процессоре Android работает вполне себе шустро? Тут все просто — Android изначально оптимизировали под слабые устройства, и поэтому никаких проблем с быстродействием нет. Ровно также на Pentium 4 летала Windows XP — эта ОС могла работать на процессорах с частотой в 300 МГц, то есть на порядок ниже. Это же касается и мобильных браузеров — они работают в масштабе 1:2, а то и 1:3 — то есть реальное разрешение в браузере будет не 1920х1080, а 640х360 — поэтому опять же нет никаких тормозов.
Теперь давайте на минутку представим, что в телефоне действительно стоит Pentium 4 (вообще говоря — предположение вполне себе верное: если программа под ПК требует процессор определенной производительности, то оптимизированная под мобильные ОС версия программы с тем же функционалом вряд ли будет иметь меньшие системные требования). Что из современного софта мы сможем запустить?
Второй миф, который запустила Nvidia больше 5 лет назад на презентации своего процессора Tegra 2 — это игры «консольного уровня». Что самое забавное — с тех пор каждый производитель счел своим долгом на презентациях говорить, что вот сейчас мы точно достигли уровня консолей. Только вот вопрос — каких?
В одном из самых мощных смартфонов современности, Apple iPhone 6s, стоит видеочип PowerVR GT 7600, производительность которого, если судить по сайту AnandTech, составляет 115 GFLOPS:
В iPhone 7 стоит чип GT 7600 PLUS, который является разогнанной версией 7600, то есть его производительность составляет 130-140 GFLOPS. Ближайшая из относительно современных видеокарт с такой же производительностью — Nvidia GT 610: 
Чтобы было понятнее — это видеокарта-затычка пятилетней давности, охлаждаемая пассивно и стоящая на данные момент меньше 2 тысяч рублей. От середнячка предыдущего поколения видеокарт Nvidia — GTX 960 — она отстает в 15 раз, а производительность в современных играх аховая: GTA 5 идет в 800х600 на минимальных настройках с 25-30 fps, Witcher 3 в 1024х768 опять же на минимальной графике выдает 7-10 fps. Консоли предыдущего поколения, PlayStation 3 и Xbox 360, выдают порядка 220-250 GFLOPS, то есть они вдвое мощнее графического процессора в iPhone 7! В итоге получается, что топовые мобильные видеочипы имеют производительность между PlayStation 2 и 3, то есть уровень видеокарт 2004-2005 года. Поэтому предел мечтаний — игры того времени, что мы и видим: под мобильные ОС с хорошей графикой были портированы GTA вплоть до San Andreas (2004), Half-Life 2 (2004), Titan Quest (2006).
Что же в итоге? А в итоге топовые смартфоны и планшеты имеют уровень производительности компьютеров 2004-2005 года, поэтому говорить о полноценной работе и играх на них просто смешно: их предел это мультимедиа и серфинг в интернете, а все рассказы производителей о том, что планшеты и смартфоны заменят ПК — увы, просто байки.
Источник
