Архивы: по дате | по разделам | по авторам

RISK vs. CISC

Архив
автор : Крис Касперски   07.09.1999

Нет четкой грани между богами и людьми: одни переходят в других.

Френк Херберт. "Мессия Дюны"


Сокращение "RISC" нередко ассоциируется с PowerPC, новыми технологиями, высокопроизводительными серверами и узкоспециализированными рабочими станциями; словом, предполагается, что RISC - это хорошая архитектура, которой противопоставляется CISC, представленная в основном семейством микропроцессоров 80x86, поддерживаемым Intel, AMD, Cyrix и NEC.

Поговаривают, что концепция CISC давно устарела, и компаниям, поддерживающим эту плохую архитектуру, пророчествуют грядущий кризис и сход с дистанции в гонке производителей.

Однако Intel, невзирая на прогнозы, расширяет рынок не только количественно, но и качественно (Pentium Pro трудится в ASCI RED - самом быстром на сегодня суперкомпьютере, в многочисленных серверах и рабочих станциях, некогда монопольно принадлежащих RISC-системам), вносит свой вклад в разработку и совершенствование микропроцессов семейства 80x86 и AMD.

"Года два назад вы покупали продукцию Intel из-за ее цены, а RISC-процессоры из-за их производительности. Сегодня Intel ликвидировала эту брешь в производительности", - говорит Джим Гарден из аналитической компании Technology Business Research.

Действительно, сегодня для потребителя не так критична архитектура микропроцессора, как совместимость с массовым программным обеспечением и уверенность в поставщике.

Поклонники PowerPC комментируют эту ситуацию как "посредственность всегда завоевывает мир". На архитектуру 80x86 продолжаются многочисленные нападки. Среди аргументов - отсутствие "нормальной" адресации (при этом стыдливо умалчивается, что в PowerPC способов адресации на порядок меньше и все они поддерживаются даже 8086) и "кривость" кода (на самом деле корявость отдельных инструкций совершенно не ухудшает архитектуру микропроцессора в целом). Примечательно, что почти все критики мыслят в стиле "Пастернака не читал, но хочу сказать..."

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

Даже ассемблер не дает представления об архитектуре процессора, ибо делает большой шаг в абстрагировании команд и операций. Лишь программирование непосредственно в двоичных кодах дает право на критику недостатков архитектуры. В противном случае это все равно, что слепому ощупывать слона.

Не бывает плохих архитектур. Бывают ориентированные на производительность, себестоимость, простоту технической реализации и так далее. Невозможно взвешивать на одних весах километры и литры. Чип, работающий в наручных часах, по сравнению даже с 8086, очень плохой. "Ведь он же всего четырехразрядный", - воскликнет критик! Что ж, установим Pentium II, музыкальный синтезатор, а пьезопищалку заменим колонками S-90? Но не получим ли мы тогда иной прибор, а не привычные наручные часы?

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

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

Явление RISC

Законы кибернетики гласят: при построении процессора можно обойтись всего одним типом вентилей - стрелками Пирса (вентиль ИЛИ-НЕ) или штрихами Шеффера (И-НЕ). То есть с их помощью можно решить любую мыслимую задачу: вычислить квадратный корень или синус, возвести в степень, даже распознать речь!

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

NOT == PIRS(A,A);
OR == PIRS(PIRS(A,B), PIRS(A,B));
AND == NOT [OR(NOT(A), NOT(B))];
CMP == OR [AND(A,B), NOT(OR(A,NOT(C)))];


Попробуйте раскрыть скобки и сравнить и объем полученного кода, и необходимый багаж математических знаний с тем, что пишут ассемблерщики сегодня:

CMP A,B
JZ C
Или то же на языке Basic:
IF A=B THEN C


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

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

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

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

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

Эти четыре операции заменила одна инструкция "CALL" - немного медленнее, зато удобнее.

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

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

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

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

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

Тут мы остановимся и поговорим о том, почему компиляторы никогда не обгонят человека. Отвлечемся на небольшой анекдот. Физику и математику дали стакан, кипяток, заварку и попросили изготовить чай. Не мудрствуя лукаво, люди науки насыпали в стакан заварки и залили ее кипятком. Во второй задаче условия изменились: стакан уже содержал кипяток, требовалось с помощью заварки приготовить чай. Физик, пожав плечами, поступил, как и любой нормальный человек на его месте. А вот математик не растерялся, вылил кипяток и пояснил: теперь решение задачи сводится к предыдущему.

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

Разработчики компиляторов шутили: есть только один способ заставить компилятор эффективно решать задачи - полностью их перечислить. Но шутки шутками, а все многообразие команд микропроцессоров становилось невостребованным. Компиляторы, теряясь в нем, использовали лишь малую толику команд: остальные валялись в дальнем углу чулана, покрытые пылью от бесхозности  [1].

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

Упростилась до предела и адресация команд. В самом деле, для чего компиляторам десятки вариантов, когда они предпочли бы один. Рассмотрим, как, например, компилятор Турбо-Паскаля фирмы Borland складывал два числа:

B:=1 ;
A:= A +B ; Увеличить переменную А на единицу

Результат компиляции:
MOV AX,1 ; Занести в регистр AX единицу
MOV BX, offset A ; Получить указатель на переменную A
MOV CX,[BX] ; Прочесть значение переменной A в регистр CX
ADD CX,AX ; Сложить и записать результат сложения в СX
MOV [BX],CX ; Записать результат в переменную A

Человек то же самое записал бы так:
ADD [offset A],1

или , что короче
INC [offset A]

Одна команда вместо пяти и ни одного используемого регистра вместо трех! Можно было улучшать компиляторы, но разработчики просто изъяли адресацию ПАМЯТЬ Ы КОНСТАНТА из набора микропроцессора.

Большинство RISC'ов на сегодняшний день использует только три вида адресации:

РЕГИСТР Ы РЕГИСТР
РЕГИСТР Ы КОНСТАНТА
РЕГИСТР Ы ПАМЯТЬ

Причем операндами во всех операциях вычисления могут быть только регистры. Понятно, что теперь их потребуется значительно больше. Тогда как семейству 80x86 вполне хватало всего восьми регистров общего назначения, большинство RISC-процессоров содержало до 64 (!) для достижения не лучшей производительности на той же тактовой частоте.

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

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

Но джин был уже выпущен из бутылки: новые микропроцессоры получили название RISC (Reduced Instruction Set Computer - компьютер с ограниченным набором команд), а все остальные, стало быть, - CISC, от слова "Complex", то есть сложный, полный, или, уж совсем дословно, - комплексный набор инструкций.

Некая комичность такой классификации станет понятна, если задаться вопросом: а что получится, если в типичном CISC-процессоре "забыть" о части инструкций? Неужели будет сразу RISC? Пытаясь определить принадлежность конкретных моделей к той или иной группе, обращали внимание на то, что "RISC-процессоры, как правило, содержат много регистров и работают на высокой тактовой частоте". Ну, "много" - понятие о-очень относительное. Например, i862 содержит тысячу двадцать четыре регистра, но поддерживает загружаемый набор инструкций, сложнейшую на сегодняшний день систему адресации памяти и, кроме того, загружаемый набор команд, так что может быть однозначно классифицирован как CISC-микропроцессор. Да и RISC-процессоры с небольшим числом регистров - не такая редкость даже сегодня.

Ну, а тактовая частота - дело и вовсе наживное. Разница становится малосущественой. Пятисотмегагерцовые Pentium II и Celeron сравнимы по частоте с большинством процессоров семейства RISC. Поэтому нет и не может быть однозначного критерия классификации. Даже число команд еще вчерашних "отъявленнейших" представителей RISC сегодня неудержимо растет. А чего же еще оставалось ждать? Разработчики ищут пути повышения производительности.

На ум приходит такая картина. Стоит посреди реки камень (то бишь проблема производительности). Одна волна обходит его справа (CISC), другая слева (RISC), но за камнем они вновь сходятся вместе.

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

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

RISC вырываются вперед

Для понимания дальнейшего сравним организацию команд двух архитектур. Типичный представитель CISC Intel 80x86 имеет следующий формат инструкций.



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



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

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

Формат команд RISC-процессоров невероятно прост.

КОД КОМАНДЫ | ОПЕРАНД 1 | ОПЕРАНД 2

Некоторые модели использовали концепцию раздельных источников и приемников, соответственно:

КОД КОМАНДЫ | ИСТОЧНИК1 | ИНСТОЧНИК 2 | ПРИЕМНИК

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

Это позволяло свести простои процессора и время ожидания загрузки к нулю, что заметно подняло производительность. Чтобы ускорить загрузку команд из памяти, разработчики были вынуждены увеличить объем кэша, что помогало, только пока программы целиком умещались в кэше. Стоило чуть-чуть превысить отведенный лимит, как производительность падала в десятки раз.

Но это была скорее забота компиляторов: разбить код так, чтобы любые его фрагменты "влезали" в отведенный кэш. И такие компиляторы очень скоро появились. RISC вырвался вперед. ПРавда, не столько за счет самой архитектуры... Игрой слепого случая механизмы предсказания ветвления были реализованы впервые именно на RISC-процессорах. Быть может, потому, что в малом наборе команд условные переходы встречались куда чаще и "портили всю малину" параллельному исполнению команд. В самом деле, какой смысл исполнять код, результат которого не понадобится?

Тем временем на фронте CISC-процессоров разработчики были больше озабочены тем, как ускорить выборку и декодирование инструкций.

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

На деле все оказалось иначе...

CISC догоняет

10 мая 1992 года четверо инженеров Intel в аэропорту Сан-Хосе ожидали самолета из Орегона. Когда шасси лайнера коснулось еще по-утреннему холодной бетонной полосы, вся встречающая группа с нетерпением и нескрываемым волнением двинулась к трапу.

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

Разумеется, речь идет о микропроцессоре Pentum - детище разработчиков 5-й Орегонской фабрики, результате трехлетнего труда многих людей, инициаторе нового передела рынка компьютеров. Sun Microsystems, MIPS и другие разработчики RISC-процессоров безоговорочно признали лидерство Pentium среди микропроцессоров этого класса.

Pentium с тактовой частотой 66 МГц работал со скоростью, практически не уступавшей RISC-процессору Alpha Digital. К тому же Pentium был полностью совместим с 80х86 семейством микропроцессоров и имел многомиллионный рынок потенциальных покупателей. Это позволяло продавать Pentium значительно дешевле, чем "более простые" RISC-микропроцессоры.

Казалось бы, миф о RISC должен был рухнуть. Intel монопольно владела рынком мини-компьютеров и решительно наступала на рынки серверов и высокопроизводительных рабочих станций. Рынок RISC-микропроцессоров сосредоточился тогда лишь на "малотиражном" Apple, кластерных суперкомпьютерах (ну, для этих вообще критична только стоимость процессоров, да и многие суперкомпьютеры построены на базе Pentium Pro) и серверах (где, вообще говоря, ПО меняется не каждый день).

Архитектура, рынок которой сокращался, вероятно, не могла называться хорошей.

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

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

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

Микрокод процессора был переписан, и большая часть инструкций реализована аппаратно. В результате большинство инструкций выполнялось за один такт. Обратим внимание: сложных инструкций, аналоги которых в RISC-процессорах распадались на десятки команд. Можно было обогнать Pentium, подняв тактовую частоту, что и сделали производители.

Все компании оказались втянутыми в "гонки на выживание": день ото дня тактовая частота микропроцессоров росла, увеличивать ее становилось труднее и труднее. Возникали сложности с отводом тепла от греющихся проводников. Уменьшение поверхности рассеивания включало в игру ионный ветер, букет квантовых эффектов и даже космическое излучение!

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

При этом, одна команда CISC заменяет десятки элементарных операций RISC, а значит, и работает быстрее. Кроме того, CISC более приятна и проста в программировании. Это был конец RISC как идеализированной концепции. Но король умер - да здравствует король! Ведь ядро самого популярного микропроцессора на сегодня - Pentium - построено не на чем ином, как на RISC-машине.

Время "противостояния" закончилось. Два клана объединились.

RISC переходит в другой лагерь

Набор команд первых RISC-процессоров смущал не только программистов, но даже самих разработчиков. Шутка ли сказать: многие из них даже не умели целочисленно умножать и делить! А зачем усложнять процессор? Умножение - это ведь многократное сложение. Ну, а деление, стало быть, - вычитание. Потребуются они программисту - он реализует это в виде цикла. Правда, цикла у нас тоже нет... ну, тогда счетчика с условным переходом.

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

Разумеется, концепция упрощенной архитектуры не одобряла аппаратную реализацию большинства новых команд. Разработчики обратились к уже знакомой нам схеме микрокод+ПЗУ. Правда, ПЗУ это было особое, выполненное по новой технологии. Обычное было бы не в состоянии обеспечить требуемую скорость доступа.

Разработчики остановили выбор на ПЛИС (программируемых логических интегральных схемах)  [2]. Они позволяли программно скомпоновать на одном кристалле электронную схему, эквивалентную аппаратной реализации на стандартных вентилях. "Чистый" RISC-процессор с ПЛИСом стал невероятно похож на "чистый" CISC с ПЗУ и тем же ПЛИСом. Собственно, ПЛИС не являлась принаждежностью архитектуры RISC и, если не углубляться в технические детали, была функционально сопоставима со старым добрым ПЗУ, во многом его превосходя. Скорость исполнения микрокода приближалась к лучшим аппаратным реализациям, и к тому же ПЛИСы сами могли декодировать и выбирать инструкции. В шутку можно сказать: ПЗУ с самообслуживанием.

Но важно было другое: ПЛИС позволяла большинство макроопераций исполнить за один такт, тогда как обращение к ПЗУ требовало этих тактов десятки.

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

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

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

Идея заключалась в следующем. Пусть часть команд имеет операнды до, а часть - после поля кода операции. Тогда:

Ранее было:

ИНСТРУКЦИЯ БЕЗ ОПЕРАНДОВ | НЕЗНАЧАЩИЙ ОПЕРАНД 1 | НЕЗНАЧАЩИЙ ОПЕРАНД 2 | ИНСТРУКЦИЯ 2

Теперь:

ИНСТРУКЦИЯ БЕЗ ОПЕРАНДОВ | ЗНАЧАЩИЙ ОПЕРАНД 1 | ЗНАЧАЩИЙ ОПЕРАНД 2 | ИНСТРУКЦИЯ 2

Но это же... система команд с переменной длиной инструкций! Разве это не основная идея CISC-архитектур? Да, пусть она достигнута другими техническими приемами, но не в этом дело. RISC шла по стопам CISC. Идея, впервые реализованная в Pentium, - спаривание нескольких микроопераций переменной длины в фиксированные по размеру машинные слова - стала буквально спасением для RISC-архитектур на пути повышения компактности кода.

Почему "чистые" RISC-процессоры не победили? Вспомним, что с самого начала RISC'ами назвали только конкретные технические решения, а "все остальные" назвали CISC'ами. Разумеется, что "всех остальных" было значительно больше.

AMD, NexGen vs. Intel

Первой компанией, которой пришла в голову мысль об интеграции RISC- и CISC-идеологий в одном процессоре, была мало кому известная NexGen. Оригинальные архитектурные решения, разработанные этой компанией, позднее были использованы во многих моделях микропроцессоров. Крошечной фирме NexGen удалось опередить Intel и AMD в создании микропроцессора пятого поколения, который был выпущен в 1995 году.

Nx586 объединил преимущества RISC-архитектур, сохранив при этом совместимость с набором инструкций серии 80x86. Новая архитектура получила название RISC-86. Революционность идеи заключалась в создании независимого транслятора команд 80x86 в набор инструкций, выполняемых RISC-ядром процессора, очень сильно напоминающим серию Alpha.

Такой подход оказался очень перспективным. Действительно, исполнять код лучше на простом и высокоскоростном RISC-ядре, а вот программировать (то бишь общаться с процессором) - на высокоуровневом CISC-языке. Так, например, работают процессоры с аппаратной поддержкой Java, не получившие пока широкого распространения.

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

Дальнейшие разработки требовали существенных расходов, поэтому наименьшим злом NexGen выбрала сотрудничество с AMD (после появления на рынке микропроцессора Pentium Pro, реализующего те же идеи и создавшего явную угрозу для сектора рынка AMD, если та не предложит аналогичной разработки).

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

Вместо двух конвейеров AMD использовала пять блоков выборки и улучшенный декодер инструкций 80x86, но это только детали технической реализации. Архитектурно и в том, и в другом случае сердцем микропроцессора становилось высокопроизводительное RISC-ядро.

RISC + CISC = ???

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

RISC'и не проиграли. Оказались не у дел компании, отказавшиеся от интеграции новых технологий, нарушающих "чистоту" RISC-архитектуры, в свои продукты. Потребителю ведь по большому счету совершенно все равно, "грязный" он покупает процессор или нет. За исключением фанатов и поклонников (хотя трудно представить поклонника RISC-архитектуры) покупательная способность определяется все же ценовой политикой производителей (не путать с себестоимостью), производительностью и еще в большей мере - совместимостью с существующим программным обеспечением. Вообще-то, стремление увеличить производительность и сохранить совместимость - вещи суть противоположные.

Разработчики оказываются в плену старых решений, со всех сторон зажатые тисками совместимости. Необходимо на старом фундаменте построить новое здание. Вызывает немое восхищение, что, оставаясь полностью совместимым с программным обеспечением, написанным десятилетия назад, Pentium полностью работает на RISC-ядре. Да только ли он? Концепция раздельного ядра и набора команд стала основной для микропроцессоров нынешнего поколения.

Сочетание CISC- и RISC-архитектур в одном микропроцессоре позволило преодолеть ограничение набора 80х86 и достичь производительности, оставляющей позади многие RISC-машины.

Никто не сомневается, что именно эта технология будет доминировать ближайшие несколько лет. Тем более, что с появлением VLIW- и EPIC-архитектур конкуренция между RISC и CISC потеряла всякий смыл. Казалось бы, диаметрально противоположный принцип EPIC-архитектуры может быть успешно совмещен с набором команд 80x86: готовящийся к выпуску Merced объединит в своем керамическом корпусе все четыре вышеназванные концепции.

У архитектур нет недостатков. Недостатки свойственны конкретным реализациям.



1 (обратно к тексту) - При этом программист мог ничего не знать ни об архитектуре микропроцессора, ни о наборе команд. Все за него решал компилятор. Никого не интересовало, во что превратится выражение "printf("Hello, Sailor! \n");": достаточно было знать, что оно независимо от процессора выведет эту строку на экран.

2 (обратно к тексту) - ПЛИСы представляют собой матрицу логических ячеек, соединенных логическими ключами. Поведение ключей зависит от введенной в память микросхемы логической матрицы (программы). Это позволяет на основе стандартной аппаратной реализации получать различные логические устройства. Таким образом мы получаем универсальный программно-аппаратный исполнитель микрокода, по техническим параметрам ничуть не уступающий своим предшественникам.



© ООО "Компьютерра-Онлайн", 1997-2022
При цитировании и использовании любых материалов ссылка на "Компьютерру" обязательна.