Новогодние бенчмарки компьютеров Эльбрус29.12.2020 05:02

Продолжение статьи Большое тестирование процессоров различных архитектур. В этот раз я решил измерить производительность конкретных сред/языков программирования (C#, Java, JavaScript, Python, Lua) на компьютерах с процессорами Эльбрус и сравнить их с компьютерами (даже телефонами) на процессорах архитектурой ARM и X86–64.

Языки программирования:

• C#
• PHP
• JavaScript (Browser, не NodeJS)
• Java
• Python
• Lua

Список тестов

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

Тестовые стенды и их процессоры

А пока можете опробовать JavaScript версию бенчмарка: http://laseroid.azurewebsites.net/js-bench/

Стенды на процессорах x86 (i386) х86–64 (amd64):

• Core i7–2600, 4 ядра 8 потоков, 3.4 ГГц
• AMD A6–3650, 4 ядра, 2.6 ГГц
• Atom Z8350, 4 ядра, 1440 МГц
• Core i3-m330, 2 ядра 4 потока, 2.13 ГГц
• Pentium 4 2800, 1 ядро, 2.8 ГГц
• Allwinner A64 (Orange Pi Win), 4 ядра Cortex A53, 1152 МГц
• Qualcomm 625 (Xiaomi Note 4X), 8 ядер, 2 ГГц
• Эльбрус 8С 1300 МГц, 8 ядер
• Эльбрус 8С x4 1300 МГц, 8 ядер (сервер 4 процессорный)
• Эльбрус 8СВ 1550 МГц
• Эльбрус 2С+ 500 МГц, 2 ядра
• Эльбрус 4C 750/800 Мгц, 4 ядра
• Эльбрус 1C+ 985/1000 МГц, 1 ядро

Компилируемые бенчмарки на C/C++

Таблица с результатами с прошлой статьи

Тут выходит так: компьютеры на Эльбрусах имеют сопоставимую производительность с Intel Core i7 2600, если бы он работал на частоте 1200 — 1300 МГц (Для Эльбрус-8С), кроме теста MP MFLOPS, который хорошо распараллеливается компилятором LCC и для Эльбрус 8СВ выдаёт 325 ГФлопс, где Core i7 2600 выдавал
85 ГФлопс (Это с SSE, без AVX).

Задержки кеша. Тест TLB от Линуса Торвальдса

Задержки кеша на Эльбруса 8СВ таковы:

• L1: 3 такта с 1,94 нс
• L2: 11 тактов с 7,1 нс
• L3: 3 такта с 21,31 нс
• ОЗУ: 90–180 тактов с 117 нс

Характеристики кеша для Эльбрус 8С можно посмотреть здесь: Архитектура Эльбрус 8С

Исходный код: Test TLB

Тесты памяти STREAM

Array size = 10000000 (elements), Offset = 0 (elements)

Memory per array = 76.3 MiB (= 0.1 GiB).

Total memory required = 228.9 MiB (= 0.2 GiB).

Исходный код: STREAM

Geekbench 4/5 (В режиме RTC: x86 → e2k трансляция)

Geekbench 5

Geekbench 4

Crystal Mark 2004 (В режиме RTC: x86 → e2k трансляция)

Процессор Эльбрус-8С 1.3 ГГц на уровне AMD Phenom II X4 965 3.4 ГГц 4 ядра. 8СВ на 20% быстрее.

Бенчмарки сред/языков программирования

А теперь переходим к бенчмаркам языков программирования (C#, Java, JavaScript, Python, Lua).

Исходный код здесь: https://github.com/EntityFX/EntityFX-Bench
Исходный код для прощлых бенчмарков можете найти тут: https://github.com/EntityFX/anybench

Микро бенчмарки

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

Arithmetics

Замеряет скорость арифметики: в цикле выполняет различные математические операции с замером времени выполнения.

Пример кода на Python:

    @staticmethod
    def _doArithmetics(i : int) -> float:
        return math.floor(i / 10) * math.floor(i / 100) * math.floor(i / 100) * math.floor(i / 100) * 1.11) + math.floor(i / 100) * math.floor(i / 1000) * math.floor(i / 1000) * 2.22 - i * math.floor(i / 10000) * 3.33 + i * 5.33

Math

Замеряет скорость математических функций (Cos, Sin, Tan, Log, Power, Sqrt):

    @staticmethod
    def _doMath(i : int, li : float) -> float:
        rev = 1.0 / (i + 1.0)
        return (math.fabs(i) * math.acos(rev) * math.asin(rev) * math.atan(rev) + math.floor(li) + math.exp(rev) * math.cos(i) * math.sin(i) * math.pi) + math.sqrt(i)

Loops

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

Conditions

Замеряет скорость работы условий.

        d = 0
        i = 0; c = -1
        while i < self._iterrations: 
            c = ((-1 if c == (-4) else c))
            if (i == (-1)): 
                d = 3
            elif (i == (-2)): 
                d = 2
            elif (i == (-3)): 
                d = 1
            d = (d + 1)
            i += 1; c -= 1
        return d

Array speed (Memory, Random Memory)

Замеряет скорость чтения из массива в переменную (последовательно или со случайными индексами)

    def _measureArrayRead(self, size) :
        block_size = 16
        i = [0] * block_size

        array0_ = list(map(lambda x: random.randint(-2147483647, 2147483647), range(0, size)))
        end = len(array0_) - 1
        k0 = math.floor(size / 1024)
        k1 = 1 if k0 == 0 else k0

        iter_internal = math.floor(self._iterrations / k1)
        iter_internal = 1 if iter_internal == 0 else iter_internal

        idx = 0
        while idx < end: 
            i[0] = (array0_[idx])
            i[1] = (array0_[idx + 1])
            i[2] = (array0_[idx + 2])
            i[3] = (array0_[idx + 3])
            i[4] = (array0_[idx + 4])
            i[5] = (array0_[idx + 5])
            i[6] = (array0_[idx + 6])
            i[7] = (array0_[idx + 7])
            i[8] = (array0_[idx + 8])
            i[9] = (array0_[idx + 9])
            i[0xA] = (array0_[idx + 0xA])
            i[0xB] = (array0_[idx + 0xB])
            i[0xC] = (array0_[idx + 0xC])
            i[0xD] = (array0_[idx + 0xD])
            i[0xE] = (array0_[idx + 0xE])
            i[0xF] = (array0_[idx + 0xF])
            idx += block_size

        start = time.time()
        it = 0

        while it < iter_internal: 
            idx = 0
            while idx < end: 
                i[0] = (array0_[idx])
                i[1] = (array0_[idx + 1])
                i[2] = (array0_[idx + 2])
                i[3] = (array0_[idx + 3])
                i[4] = (array0_[idx + 4])
                i[5] = (array0_[idx + 5])
                i[6] = (array0_[idx + 6])
                i[7] = (array0_[idx + 7])
                i[8] = (array0_[idx + 8])
                i[9] = (array0_[idx + 9])
                i[0xA] = (array0_[idx + 0xA])
                i[0xB] = (array0_[idx + 0xB])
                i[0xC] = (array0_[idx + 0xC])
                i[0xD] = (array0_[idx + 0xD])
                i[0xE] = (array0_[idx + 0xE])
                i[0xF] = (array0_[idx + 0xF])
                idx += block_size
            it += 1

        elapsed = time.time() - start
        return (iter_internal * len(array0_) * 4 / elapsed / 1024 / 1024, i)

String manipulation

Скорость работы со строковыми функциями (replace, upper, lower)

    @staticmethod
    def _doStringManipilation(str0_ : str) -> str:
        return ("/".join(str0_.split(' ')).replace("/", "_").upper() + "AAA").lower().replace("aaa", ".")

Hash algorithms

Алгоритмы SHA1 и SHA256 над байтами строк.

    @staticmethod
    def _doHash(i : int, prepared_bytes):
        hashlib.sha1()
        sha1_hash = hashlib.sha1(prepared_bytes[i % 3]).digest()
        sha256_hash = hashlib.sha256(prepared_bytes[(i + 1) % 3]).digest()
        return sha1_hash + sha256_hash

Комплексные бенчмарки

Выполнил реализацию популярных бенчмарков Dhrystone, Whetstone, LINPACK, Scimark 2 на всех 5 языках программирования (конечно же использовал существующие исходники, но адаптировал под мои тесты).

Dhrystone

Dhrystone — синтетический тест, который был написан Reinhold P. Weicker в 1984 году.
Данный тест не использует операции с плавающей запятой, а версия 2.1 написана так, чтобы исключить возможность сильных оптимизаций при компиляции.
Бенчмарк выдаёт результаты в VAX Dhrystones в секунду, где 1 VAX DMIPS = Dhrystones в секунду делить на 1757.

Whetstone

Whetstone — синтетический тест, который был написан Harold Curnow в 1972 году на языке Fortran.
Позже был переписан на языке C Roy Longbottom. Данный тест выдаёт результаты в MWIPS,
также промежуточные результаты в MOPS (Миллионов операций в секунду) и MFLOPS (Миллионы вещественных операций с плавающей запятой в секунду).
Данный тест производит различные подсчёты: производительность целочисленных и операций с плавающей запятой,
производительность операций с массивами, с условным оператором, производительность тригонометрических функций и функций возведения в степень, логарифмов и извлечения корня.

LINPACK

LINPACK — тест, который был написан Jack Dongarra на языке Fortran в 70х годах, позже переписан на язык C.
Тест считает системы линейных уравнений, делает различные операции над двумерными (матрицами) и одномерными (векторами).
Используется реализация Linpack 2000×2000.

Scimark 2

SciMark 2 — набор тестов на языке C измеряющий производительность кода встречающегося в научных и профессиональных приложениях. Содержит в себе 5 вычислительных тестов: FFT (быстрое преобразование Фурье), Gauss-Seidel relaxation (Метод Гаусса — Зейделя для решения СЛАУ), Sparse matrix-multiply (Умножение разреженных матриц), Monte Carlo integration (Интегрирование методом Монте-Карло), и LU factorization (LU-разложение).

Переходим к результатам.

Результаты

Бенчмарки Java

Результаты Java на Эльбрусах в сравнении с Core i7 2600 4 ядра, 8 потоков 3.4 ГГц:

• Эльбрус 1С+ в 11 раз медленнее на 1 поток
• Эльбрус 4С в 10 раз медленнее на 1 поток
• Эльбрус 8С в 5,5 раз медленнее на 1 поток
• Эльбрус 8СВ в 4,5 раз медленнее на 1 поток
• Эльбрус 1С+ в 18 раз медленнее на всех потоках
• Эльбрус 4С в 12,5 раз медленнее на всех потоках
• Эльбрус 8С в 3 раз медленнее на всех потоках
• Эльбрус 8СВ в 2,5 раз медленнее на всех потоках

Результаты Java на Эльбрусах в сравнении с Core i7 2600 4 ядра, 8 потоков, но на одинаковых частотах:

• Эльбрус 1С+ в 3,5 раз медленнее на 1 поток Core i7 2600 на частоте 1 ГГц
• Эльбрус 4С в 2,5 раз медленнее на 1 поток Core i7 2600 на частоте 0,8 ГГц
• Эльбрус 8С в 2 раз медленнее на 1 поток Core i7 2600 на частоте 1,3 ГГц
• Эльбрус 8СВ в 2 раз медленнее на 1 поток Core i7 2600 на частоте 1,55 ГГц
• Эльбрус 1С+ в 5 раз медленнее на всех потоках Core i7 2600 на частоте 1 ГГц
• Эльбрус 4С в 2,75 раз медленнее на всех потоках Core i7 2600 на частоте 0,8 ГГц
• Эльбрус 8С в 1,15 раз медленнее на всех потоках Core i7 2600 на частоте 1,3 ГГц
• Эльбрус 8СВ в 1,15 раз медленнее на всех потоках Core i7 2600 на частоте 1,55 ГГц

Для Java делали очень серьёзные оптимизации, поэтому отставание в 2 раза на одинаковых частотах не является плохим результатом.

Про то, как оптимизировали Java можно почитать тут: Java на Эльбрусе

Посмотреть здесь:

Бенчмарки C# (.Net Framework, .Net Core, Mono)

Так как сред исполнения несколько (.Net Framework, .Net Core, Mono), то я старался сравнивать одинаковые среды исполнения, т. е. Mono на e2k c Mono на x86.

Результаты C# (Mono) на Эльбрусах в сравнении с Core i7 2600 4 ядра, 8 потоков 3.4 ГГц:

• Эльбрус 1С+ в 15,5 раз медленнее на 1 поток
• Эльбрус 4С в 19 раз медленнее на 1 поток
• Эльбрус 8С в 10,5 раз медленнее на 1 поток
• Эльбрус 8СВ в 8 раз медленнее на 1 поток
• Эльбрус 1С+ в 24 раз медленнее на всех потоках
• Эльбрус 4С в 12,5 раз медленнее на всех потоках
• Эльбрус 8С в 4,5 раз медленнее на всех потоках
• Эльбрус 8СВ в 4 раз медленнее на всех потоках

Результаты C# (Mono) на Эльбрусах в сравнении с Core i7 2600 4 ядра, 8 потоков, но на одинаковых частотах:

• Эльбрус 1С+ в 4,5 раз медленнее на 1 поток Core i7 2600 на частоте 1 ГГц
• Эльбрус 4С в 4,2 раз медленнее на 1 поток Core i7 2600 на частоте 0,8 ГГц
• Эльбрус 8С в 3 раз медленнее на 1 поток Core i7 2600 на частоте 1,3 ГГц
• Эльбрус 8СВ в 3 раза медленнее на 1 поток Core i7 2600 на частоте 1,55 ГГц
• Эльбрус 1С+ в 7 раз медленнее на всех потоках Core i7 2600 на частоте 1 ГГц
• Эльбрус 4С в 3 раза медленнее на всех потоках Core i7 2600 на частоте 0,8 ГГц
• Эльбрус 8С в 1,5 раз медленнее на всех потоках Core i7 2600 на частоте 1,3 ГГц
• Эльбрус 8СВ в 1,2 раз медленнее на всех потоках Core i7 2600 на частоте 1,55 ГГц

Результаты C# (NetCore) в режиме RTC на Эльбрусах в сравнении с Core i7 2600 4 ядра, 8 потоков 3.4 ГГц:

• Эльбрус 8С в 3,5 раз медленнее на 1 поток Core i7 2600 на частоте 1,3 ГГц
• Эльбрус 8СВ в 3 раз медленнее на 1 поток Core i7 2600 на частоте 1,55 ГГц
• Эльбрус 8С в 2 раз медленнее на всех потоках Core i7 2600 на частоте 1,3 ГГц
• Эльбрус 8СВ в 1,5 раз медленнее на всех потоках Core i7 2600 на частоте 1,55 ГГц

Результаты C# (NetCore) в режиме RTC на Эльбрусах в сравнении с Core i7 2600 4 ядра, 8 потоков, но на одинаковых частотах:

• Эльбрус 8С в 1,3 раз медленнее на 1 поток Core i7 2600 на частоте 1,3 ГГц
• Эльбрус 8СВ в 1,2 раз медленнее на 1 поток Core i7 2600 на частоте 1,55 ГГц
• Эльбрус 8С в 1,25 раза быстрее на всех потоках Core i7 2600 на частоте 1,3 ГГц
• Эльбрус 8СВ в 1,25 раза быстрее на всех потоках Core i7 2600 на частоте 1,55 ГГц

Mono сам по себе является достаточно медленной средой выполнения по сравнению с Net Fremework, а особенно с NetCore (до 3х раз). Что достаточно допустимо. Здесь я не знаю, делали ли оптимизации как это было сделано с Java.

Выходит NetCore в режиме RTC на Эльбрусах работает до 4х раз быстрее чем Mono. Будем ждать нативного NetCore для e2k.

Бенчмарки JavaScript (Браузерные)

JavaScript версия бенчмарка: http://laseroid.azurewebsites.net/js-bench/

Результаты JavaScript на Эльбрусах в сравнении с Core i7 2600 4 ядра, 8 потоков 3.4 ГГц:

• Эльбрус 1С+ в 16 раз медленнее
• Эльбрус 4С в 12,5 раз медленнее
• Эльбрус 8С в 6,5 раз медленнее
• Эльбрус 8СВ в 5 раз медленнее

Результаты JavaScript на Эльбрусах в сравнении с Core i7 2600 4 ядра, 8 потоков, но на одинаковых частотах:

• Эльбрус 1С+ в 5 раз медленнее Core i7 2600 на частоте 1 ГГц
• Эльбрус 4С в 2,75 раза медленнее Core i7 2600 на частоте 0,8 ГГц
• Эльбрус 8С в 2,5 раза медленнее Core i7 2600 на частоте 1,3 ГГц
• Эльбрус 8СВ в 2,25 раз медленнее Core i7 2600 на частоте 1,55 ГГц

Другие популярные JavaScript бенчмарки

Octane

Firefox (версии разные)

Kraken Benchmark

Firefox (версии разные)

Sunspider

Firefox (версии разные)

Результаты слабоваты. Причина: низкие тактовые частоты и недостаточная оптимизация. Но это гораздо лучше, чем было раньше. Также браузер FX52 уже старый, а будет новая, надеюсь, там уже допилили JavaScript.

Бенчмарки PHP

Результаты PHP на Эльбрусах в сравнении с Core i7 2600 3.4 ГГц:

• Эльбрус 2С+ в 15,5 раз медленнее
• Эльбрус 1С+ в 8 раз медленнее
• Эльбрус 4С в 4,5 раза медленнее
• Эльбрус 8С в 3 раза медленнее
• Эльбрус 8СВ в 2,5 раза медленнее
• Эльбрус R1000 в 12,5 раз медленнее

Результаты PHP на Эльбрусах в сравнении с Core i7 2600, но на одинаковых частотах:

• Эльбрус 2С+ в 2,3 раз медленнее Core i7 2600 на частоте 0,5 ГГц
• Эльбрус 1С+ в 2,3 раз медленнее Core i7 2600 на частоте 1 ГГц
• Эльбрус 4С = Core i7 2600 на частоте 0,8 ГГц
• Эльбрус 8С в 1,1 раза медленнее Core i7 2600 на частоте 1,3 ГГц
• Эльбрус 8СВ в 1,1 раза медленнее Core i7 2600 на частоте 1,55 ГГц
• Эльбрус R1000 в 3,75 раз медленнее Core i7 2600 на частоте 1 ГГц

PHP показывает почти равную скорость на одинаковых частотах с Intel процессорами. Причина проста: здесь МЦСТ делали оптимизацию. Очень удивительно для интерпретируемого языка. Кстати, хочу обратить внимание на то что PHP 7.4 стал быстрее версии PHP 5.6 в 1,5 раза, поэтому я запускал бенчмарки на 2х версиях на Core i7 2600.

Другие популярные PHP бенчмарки

PHP Simple Benchmark

Бенчмарки Python

Так как под Windows не удалось запустить многопоточный Python (я не Питонист, да и времени сделать универсальную многопоточность на всех ОС не было, принимаю патчи), приведу относительно Amd A6 3650, который на 40% медленнее Core i7.

Результаты Python на Эльбрусах в сравнении с Core i7 2600 3.4 ГГц:

• Эльбрус 2С+ в 30 раз медленнее на 1 поток
• Эльбрус 1С+ в 12,5 раз медленнее на 1 поток
• Эльбрус 4С в 15,5 раз медленнее на 1 поток
• Эльбрус 8С в 9 раз медленнее на 1 поток
• Эльбрус 8СВ в 7,8 раз медленнее на 1 поток
• Эльбрус 2С+ в 58 раз медленнее на всех потоках
• Эльбрус 1С+ в 25 раз медленнее на всех потоках
• Эльбрус 4С в 13,5 раз медленнее на всех потоках
• Эльбрус 8С в 4,2 раза медленнее на всех потоках
• Эльбрус 8СВ в 3,8 раза медленнее на всех потоках

Результаты Python на Эльбрусах в сравнении с Core i7 2600, но на одинаковых частотах:

• Эльбрус 2С+ в 4,5 раз медленнее на 1 поток Core i7 2600 на частоте 0,5 ГГц
• Эльбрус 1С+ в 3,6 раз медленнее на 1 поток Core i7 2600 на частоте 1 ГГц
• Эльбрус 4С в 3,5 раз медленнее на 1 поток Core i7 2600 на частоте 0,8 ГГц
• Эльбрус 8С в 3,5 раз медленнее на 1 поток Core i7 2600 на частоте 1,3 ГГц
• Эльбрус 8СВ в 3,5 раз медленнее на 1 поток Core i7 2600 на частоте 1,55 ГГц
• Эльбрус 2С+ в 8,5 раз медленнее на всех потоках Core i7 2600 на частоте 0,5 ГГц
• Эльбрус 1С+ в 7,4 раз медленнее на всех потоках Core i7 2600 на частоте 1 ГГц
• Эльбрус 4С в 3 раз медленнее на всех потоках Core i7 2600 на частоте 0,8 ГГц
• Эльбрус 8С в 1,5 раза медленнее на всех потоках Core i7 2600 на частоте 1,3 ГГц
• Эльбрус 8СВ в 1,35 раза медленнее на всех потоках Core i7 2600 на частоте 1,55 ГГц

Во первых, для Python пока не делалось оптимизаций, которые повысили бы производительность. Во вторых, интерпретируемые языки плохо подходят к VLIW-архитектуре Эльбруса. Но МЦСТ советуют использовать CPython для производительности (Python → C, а затем компилируем с помощью LCC). Про PyPy c Jit пока ничего не известно, но если потребуется, то такая среда выполнения будет реализована, а это сильно повысит производительность.

Также было замечено, что в некоторых случаях Python в режиме RTC (двоичная трансляция x86–64 в e2k) показывает большую производительность: в арифметике и математике. Значит есть ещё потенциал для оптимизации Python, возможно даже в 2 раза.

Бенчмарки Lua

Результаты Lua на Эльбрусах в сравнении с Core i7 2600 3.4 ГГц:

• Эльбрус 2С+ в 16 раз медленнее
• Эльбрус 1С+ в 6 раз медленнее
• Эльбрус 4С в 10 раз медленнее
• Эльбрус 8С в 6 раз медленнее
• Эльбрус 8СВ в 5 раз медленнее
• Эльбрус R1000 в 9 раз медленнее

Результаты Lua на Эльбрусах в сравнении с Core i7 2600, но на одинаковых частотах:

• Эльбрус 2С+ в 2,4 раза медленнее Core i7 2600 на частоте 0,5 ГГц
• Эльбрус 1С+ в 1,75 раза медленнее Core i7 2600 на частоте 1 ГГц
• Эльбрус 4С в 2 раза медленнее Core i7 2600 на частоте 0,8 ГГц
• Эльбрус 8С в 2,3 раза медленнее Core i7 2600 на частоте 1,3 ГГц
• Эльбрус 8СВ в 2,2 раза медленнее Core i7 2600 на частоте 1,55 ГГц
• Эльбрус R1000 в 2,6 раз медленнее Core i7 2600 на частоте 1 ГГц

У Lua отставание всего в 2 раза на равных частотах, это достаточно тепримо для VLIW-архитектуры.

Выводы

Во сколько раз Core i7 2600 быстрее Эльбрусов:

Во сколько раз Core i7 2600 быстрее Эльбрусов, если бы он работал на частоте Эльбрусов:

Как мы знаем, Эльбрус имеет VLIW архитектуру, у которой повышение производительности достигается путём оптимизации компилируемого кода (Эльбрус имеет явный параллелизм). Также у Эльбруса нет предсказателя переходов и переупорядочивания инструкций (снова всё явно задаётся компилятором).

Следует:

• Компилируемые программы на C/C++ (возможно, другие) будут иметь хорошую производительность. Это достигается патчами участков кода, где нужно оптимизировать производительность и умным компилятором LCC (eLbrus C Compiler).
• Языки с JIT-трансляцией (Java, JavaScript, C# Mono) будут иметь среднюю производительность. Здесь оптимизируют саму среду исполнения. Возможно, также потребуется оптимизировать сами программы.
• Интерпретируемые языки (PHP, Python, Lua) будут иметь низкую производительность. Но оптимизация среды выполнения позволит поднять до среднего уровня.

Другие способы:

• Доработка компилятора LCC.
• Архитектурно-специфические доработки в самой ОС.
• Улучшать архитектуру Эльбрус:
  
  • Поднимать частоту
  • Добавить предсказатель и т.д.

Какие языки ещё хотелсоь бы потестировать:

• Golang (Ждём выпуска)
• Ruby
• Perl

P.S. Поздравляем команду МЦСТ с Новым Годом. Желаем удачи в разработке следующих поколений процессоров. Ждём массового появления устройств на процессорах с архитектурой E2K!

© Habrahabr.ru