Миниобзор пекарни на Эльбрус-8С (видео)

А где посмотреть нормальные тесты?
В видео петросян запускает видосики и офис. Или он не знает как тестят процессоры или результаты такие что лучше не показывать.

Перечитай мой пост, не я предлагаю подпереть, а они предлагают развивать адаптивный JIT «в том числе и для C/Cpp, но уже не потому что языки этого требуют, а потому что это поможет производительности».
Что конкретно имеется в виду - не знаю, но подозреваю что подразумевается прогон наиболее горячих кусков через оптимизации с целью улучшения кода и извлечения большего параллелизма. Как это делает их компилятор в x86, просто перемалывать будет уже свой же собственный код.

Что такое нормальные тесты?

Перечитай мой пост

Что конкретно имеется в виду - не знаю

Оукей.

Ты кстати тут спрашивал куда их поставляют https://youtu.be/WLQU3P64Uk0?t=640

Я знаю, куда их поставляют. Выше по треду даже написано, в каких количествах.

JIT не может оптимизировать код на ц и цпп, он может житить или гостевой код, т.е. x86->e2k или нативный код, т.е. e2k->e2k.
А теперь вспомним, что компилятор для EPIC очень большой и тяжелый, поэтому jit породит огромный оверхед и просто так им не помашешь.

Я думаю, это решаемая проблема, если задаться именно этой целью и забить на остальные куски системы.

житить или гостевой код, т.е. x86->e2k или нативный код, т.е. e2k->e2k.

Но за счет чего отобьются затраты на JIT нативного кода?

https://habrahabr.ru/company/smartengines/blog/317672/#comment_9966094

Как бы код на цпп остается кодом на цпп даже в скомпилированном виде

я так понимаю ты вообще не в курсе как устроены и работают микросхемы.

У них не форк gcc у них просто компилятор совместим по опциям.

И вообще комментарии смешные, кидают тесты спек хомяки кричат «фу! синтетика! давайте реальные задачи!» показывают браузер/офис/ffmpeg «ничего не понятно, где тут процессор а где 24гб ddr3 с ссд давайте замеры производительности», кидают реальный код с замерами времени исполнения кучи итераций и в сравнении не с каким нибудь непонятным Itanium 2, Atom 2600 или Core2Duo а с самым что нинаесть современным i7.
И...

«Ну серьёзно, полное игнорирование тестов SPEC наводит на плохие мысли. Когда уже сделаете?»

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

кидают реальный код с замерами времени исполнения кучи итераций и в сравнении не с каким нибудь непонятным Itanium 2, Atom 2600 или Core2Duo а с самым что нинаесть современным i7.

которому он ужасно проигрывает

Как бы код на цпп остается кодом на цпп даже в скомпилированном виде

Чего?! Что это вообще должно означать-то?

«Ну серьёзно, полное игнорирование тестов SPEC наводит на плохие мысли. Когда уже сделаете?»

снова подавай синтетику.

Так есть где-нибудь _эта_ синтетика?

Тем что это универсальный процессор с большим потенциалом наращивания вычислительной мощности.

Основное преимущество VLIW — в вытащенном наружу разруливании зависимостей операций, чтобы это можно было делать вдумчивее. Компилятор может учесть, скажем, задержку выполнения операций. Когда в таком процессоре делаешь (в одной из команд слова) add r3, r1, r2, результат в r3 прилетает не сразу, а, скажем, через такт. То есть дальше в коде может быть add r4, r1, r3, которое использует ещё старое значение r3. И так для каждой операции. Казалось бы ну и ладно, ведь всё равно этим занимается компилятор.

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

VLIW это красивая идея, но только когда есть очень умный компилятор, который жёстко привязан к версии железа, а скомпилированный код никогда не покидает связку компилятор-железо. То есть, например, для GPU такая идея очень хорошо подходит. В драйвер подаются шейдеры в некотором промежуточном представлении, которое драйвер преобразовывает в родной код для конкретной модели GPU. Он может спокойно кешировать этот код, чтобы в следующий раз не собирать, но этот кеш никогда не выползет наружу. Для следующей модели GPU микроархитектура может быть легко изменена. Для неё будет другой компилятор.

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

Ну так еще бы, однако тут следует еще смотреть насколько именно проигрывает.
Zenom

Чего?! Что это вообще должно означать-то?

Что твое «приложение» это только «приложение» к операционной системе, которое телебонькает библиотечные функции, системные вызовы и прочее.

tailgunner
Конечно есть, сколько можно уже приводить ее
http://image.slidesharecdn.com/random-141111041412-conversion-gate02/95/-22-1...
http://image.slidesharecdn.com/random-141111041412-conversion-gate02/95/-23-1...

Хотя вообще то синтетика это же как раз считание матриц и циклы как раз есть. Ну и ладно

Это старая известная картинка. ЕМНИП, в ней какое-то мошенничество с показателями типа «MIPS на МГц».

VLIW это красивая идея

ИМХО, VLIW был неплохой идеей для начала 80-х (когда он и появился), но с тех пор процессоры научились сами параллелить лучше, чем компиляторы.

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

Основное преимущество VLIW — в вытащенном наружу разруливании зависимостей операций

А по мне так это выглядит просто как очевидная эволюционная ступень, как от OpenGL пришли к вулкану - вместо GL_DRAW_OWL дали программисту набор простых операций, что бы он сам делал себе DRAW_OWL и какую ему надо. То же самое при переходе с CISC на RISС, комплексные инструкции которые и считают и кофе варят стали неудобны, а их инстракшнсет не позволяет толком наращивать производительность, поэтому их разделили на упрощенные команды, а циск, если нужно можно спокойно поверх них реализовать, что собственно интел и сделал.

А дальше, следующим этапом, программисту нужно как то дать возможность явно этот порядок комманд задавать, и вот мы приходим к VLIW хотя само слово по моему личному мнению вообще ничего толком не отражает, тогда как в реальности подразумевается некие комманды-бандлы, которые набиваются простыми RISC подобными операциями, то есть это возможность для программиста (не для железячника) сэмитировать любой комплекс инстракшн сет какой ему хочется. VLIW это не «принципиально новый процессор с нескучными командами», VLIW это суперскалярный RISC процессор в котором подумали как избавится от всего того, что мешает задавать порядок комманд явно и как и что нужно допилить/чем его дополнить что бы приблизиться к той самой цели, архитектуре с задаваемым комплексом команд помещенными ах в четыре байта.

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

Ты кодишь? Давно появлялось желание делать свой инстракшн сет? Ну и ещё раз — это всё красиво звучит до первого апгрейда. Новый проц — новый компилятор, с новыми багами. Нельзя просто взять уже собранную для старого процессора программу и запустить.

VLIW это суперскалярный RISC процессор в котором подумали как избавится от всего того, что мешает задавать порядок комманд явно

Как будто пользователи об этом просят. Проще железячникам, сложнее программистам и особенно разработчикам компилятора. И головная боль пользователям.

что собственно интел и сделал

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

архитектуре с задаваемым комплексом команд помещенными ах в четыре байта.

Опечатка, наверное. Четыре байта, 32 бита — это далеко не Very Long. Там от 128 бит и выше.

Ты кодишь? Давно появлялось желание делать свой инстракшн сет?

«Мне не надо, значит никому не надо»

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

Это уже рутинные проблемы, которые к тому же как то решенные еще в итаниуме.

Проще железячникам, сложнее программистам

Бедные программисты, им придется писать код...

Как будто пользователи об этом просят.
Людям это очень нужно.

Еще они не просят луну, марс и квазары им и на земле хорошо, так что теперь, прекратить исследования?

Опечатка, наверное. Четыре байта, 32 бита — это далеко не Very Long. Там от 128 бит и выше.

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

Алсо: вот немножко асма на котором видно номера устройств и ноп

#define E2K_RESTORE_GREG_IN_TRAP(base, ext, numlo1, numhi1, numlo2, numhi2) \
({                                                                      \
        register u64 reg1, reg2, reg3, reg4, reg5, reg6;                \
                                                                        \
        asm (                                                           \
                "{\n"                                                   \
                "ldrd,2 [%[_base] + %[_tagged_ld_0]], %%dg" #numlo1 "\n" \
                "ldrd,5 [%[_base] + %[_tagged_ld_8]], %%dg" #numhi1 "\n" \
                "ldh,0 [%[_ext] + 0], %0\n"                             \
                "ldh,3 [%[_ext] + 2], %1\n"                             \
                "}\n"                                                   \
                "{\n"                                                   \
                "nop\n"                                                 \
                "ldrd,2 [%[_base] + %[_tagged_ld_16]], %%dg" #numlo2 "\n" \
                "ldrd,5 [%[_base] + %[_tagged_ld_24]], %%dg" #numhi2 "\n" \
                "ldh,0 [%[_ext] + 4], %2\n"                             \
                "ldh,3 [%[_ext] + 6], %3\n"                             \
                "}\n"                                                   \
                "{\n"                                                   \
                "gettagd,2 %%dg" #numlo1 ", %4\n"                       \
                "gettagd,5 %%dg" #numhi1 ", %5\n"                       \
                "}\n"                                                   \
                "{\n"                                                   \
                "gettagd,2 %%dg" #numlo2 ", %4\n"                       \
                "gettagd,5 %%dg" #numhi2 ", %5\n"                       \
                "cmpesb,1 0, %4, %%pred2\n"                             \
                "cmpesb,4 0, %5, %%pred3\n"                             \
                "}\n"                                                   \
                "{\n"                                                   \
                "cmpesb,1 0, %4, %%pred4\n"                             \
                "cmpesb,4 0, %5, %%pred5\n"                             \
                "}\n"                                                   \
                "{\n"                                                   \
                "movif,1 %%dg" #numlo1 ", %0, %%dg" #numlo1 " ? %%pred2\n" \
                "movif,4 %%dg" #numhi1 ", %1, %%dg" #numhi1 " ? %%pred3\n" \
                "}\n"                                                   \
                "{\n"                                                   \
                "movif,1 %%dg" #numlo2 ", %2, %%dg" #numlo2 " ? %%pred4\n" \
                "movif,4 %%dg" #numhi2 ", %3, %%dg" #numhi2 " ? %%pred5\n" \
                "}\n"                                                   \
                : "=&r" (reg1), "=&r" (reg2), "=&r" (reg3), "=&r" (reg4), \
                  "=&r" (reg5), "=&r" (reg6)                            \
                : [_base] "r" (base), [_ext] "r" (ext),                 \
                  [_tagged_ld_0] "i" (TAGGED_MEM_LOAD_REC_OPC),         \
                  [_tagged_ld_8] "i" (TAGGED_MEM_LOAD_REC_OPC | 8UL),   \
                  [_tagged_ld_16] "i" (TAGGED_MEM_LOAD_REC_OPC | 16UL), \
                  [_tagged_ld_24] "i" (TAGGED_MEM_LOAD_REC_OPC | 24UL)  \
                : "%g" #numlo1, "%g" #numhi1, "%g" #numlo2, "%g" #numhi2, \
                  "%pred2", "%pred3", "%pred4", "%pred5");              \
})

большую часть времени код х86-32 сосёт операции mov, так что на архитектуре с кучей регистров его заоптимизировать довольно легко. и даже на эпике

Бедные программисты, им придется писать код...

Программистам плевать. Бедные тут пользователи. Это как игорь-тонет, только для софта. Каждый новый процессор — целый новый мир, который нужно исследовать заново. Делаешь апгрейд, а у тебя не просто софт не оптимизирован и не выжимает всё возможное. ОС вообще не грузится.

итанике

Вот ты даже сам это слово упомянул. Знаешь же, почему их Itanic'ами прозвали?

«была у меня лошадь, небыло проблем с бензином»

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

да-да внутренний они могут переиначивать как захотят, но внешний легаси инстракшнсет ничего нового не позволит

Тем не менее, они чудеса делают с тем, что есть. Чего только стоят оптимизации виртуальных вызовов.

Правда и количество бабла, которое они вкачивают в разработки, тоже поражает.

это все называется схема Томассуло, и round-robin лишь кривой способ избежать попадания под ibmовский патент с отрезанием жопы. это по сути та же схема только вместо той инструкции которая первее по порядку, идет та которая первее в одной из round-robinов процессора.