Классический конвейер RISC

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

В истории компьютерного оборудования некоторые ранние компьютерные центральные процессоры с сокращенным набором команд (RISC CPU) использовали очень похожее архитектурное решение, которое теперь называется классическим конвейером RISC . Этими процессорами были: MIPS , SPARC , Motorola 88000 , а позже - условный процессор DLX, изобретенный для образования.

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

Классический пятиступенчатый конвейер RISC [ править ]

Базовый пятиэтапный конвейер в RISC- машине (IF = выборка инструкции , ID = декодирование инструкции, EX = выполнение, MEM = доступ к памяти, WB = обратная запись в регистр). Вертикальная ось - последовательные инструкции; горизонтальная ось - время. Таким образом, в зеленом столбце самая ранняя инструкция находится на стадии WB, а последняя инструкция подвергается выборке.

Получение инструкций [ править ]

Инструкции находятся в памяти, чтение которой занимает один цикл. Эта память может быть посвящена SRAM, или Instruction Cache . Термин «задержка» часто используется в информатике и означает время от начала операции до ее завершения. Таким образом, выборка команды имеет задержку в один тактовый цикл (при использовании SRAM с одним циклом или если инструкция была в кэше). Таким образом, во время выборки команды этапа, 32-битная команда извлекается из памяти инструкции.

Program Counter , или PC, является регистр , который содержит адрес , который представляется в памяти инструкции. В начале цикла адрес представляется в память команд. Затем во время цикла инструкция считывается из памяти инструкций, и в то же время выполняется расчет для определения следующего ПК. Расчет следующего ПК выполняется путем увеличения ПК на 4 и выбора того, следует ли использовать его в качестве следующего ПК или, альтернативно, использовать результат вычисления перехода / перехода в качестве следующего ПК. Обратите внимание, что в классическом RISC все инструкции имеют одинаковую длину. (Это то, что отделяет RISC от CISC ^[1]). В исходных проектах RISC размер инструкции составляет 4 байта, поэтому всегда добавляйте 4 к адресу инструкции, но не используйте PC + 4 в случае взятой ветви, перехода или исключения (см. Отложенные переходы ниже ). (Обратите внимание, что некоторые современные машины используют более сложные алгоритмы ( предсказание ветвления и предсказание цели ветвления ), чтобы угадать адрес следующей инструкции.)

Расшифровка инструкций [ править ]

Еще одна вещь, которая отличает первые машины RISC от более ранних машин CISC, заключается в том, что RISC не имеет микрокода . ^[2] В случае микрокодированных инструкций CISC, после выборки из кэша инструкций, биты инструкций сдвигаются вниз по конвейеру, где простая комбинационная логика на каждом этапе конвейера создает управляющие сигналы для канала данных непосредственно из битов инструкций. В этих конструкциях CISC очень мало декодирования выполняется на этапе, традиционно называемом этапом декодирования. Следствием этого отсутствия декодирования является необходимость использования большего количества битов инструкции для определения того, что делает инструкция. Это оставляет меньше битов для таких вещей, как индексы регистров.

Все инструкции MIPS, SPARC и DLX имеют не более двух входов регистров. На этапе декодирования индексы этих двух регистров идентифицируются в инструкции, и индексы представляются в регистровую память как адрес. Таким образом, два названных регистра считываются из файла регистров . В дизайне MIPS регистровый файл имел 32 записи.

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

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

На этапе декодирования потребовалось довольно много оборудования: MIPS имеет возможность ветвления, если два регистра равны, поэтому 32-битное дерево И выполняется последовательно после чтения файла регистров, создавая очень длинный критический путь через этот stage (что означает меньшее количество циклов в секунду). Кроме того, для вычисления цели перехода обычно требовалось 16-битное сложение и 14-битный инкремент. Разрешение ветвления на этапе декодирования позволило получить только штраф за неправильное предсказание ветвления за один цикл. Поскольку ветви очень часто брались (и, следовательно, предсказывались неверно), было очень важно сохранить низкий штраф.

Выполнить [ править ]

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

ALU отвечает за выполнение логических операций (and, or, not, nand, nor, xor, xnor), а также за выполнение целочисленного сложения и вычитания. Помимо результата, ALU обычно предоставляет биты состояния, например, был ли результат 0 или произошло переполнение.

Бит шифтер отвечает за сдвиг и повороты.

Инструкции на этих простых RISC-машинах можно разделить на три класса задержки в зависимости от типа операции:

• Операция регистр-регистр (задержка одного цикла): сложение, вычитание, сравнение и логические операции. На этапе выполнения два аргумента были переданы простому ALU, который сгенерировал результат к концу этапа выполнения.
• Ссылка на память (двухцикловая задержка). Все загружается по памяти. На этапе выполнения ALU добавил два аргумента (регистр и постоянное смещение), чтобы создать виртуальный адрес к концу цикла.
• Многоступенчатые инструкции (многоцикловая задержка). Целочисленное умножение и деление, а также все операции с плавающей запятой . На этапе выполнения операнды этих операций подавались в многоцикловый блок умножения / деления. Остальная часть конвейера могла продолжить выполнение, пока модуль умножения / деления выполнял свою работу. Чтобы не усложнять этап обратной записи и логику выдачи, инструкция мультицикла записывала свои результаты в отдельный набор регистров.

Доступ к памяти [ править ]

Если требуется доступ к памяти данных, это делается на этом этапе.

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

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

Обратная связь [ править ]

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

Опасности [ править ]

Хеннесси и Паттерсон придумали термин « опасность» для ситуаций, когда инструкции в конвейере приводят к неправильным ответам.

Структурные опасности [ править ]

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

Опасности данных [ править ]

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

В классическом конвейере RISC опасности данных можно избежать одним из двух способов:

Решение A. Обход [ править ]

Обход также известен как пересылка операндов .

Предположим, ЦП выполняет следующий фрагмент кода:

SUB  r3 , r4  ->  r10  ; Записывает r3 - r4 в r10 И  r10 , r3  ->  r11  ; Записывает r10 и r3 в r11

Этапы выборки и декодирования команд отправляют вторую инструкцию на один цикл после первой. Они стекают по трубопроводу, как показано на этой схеме:

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

В цикле 3 SUBинструкция вычисляет новое значение для r10. В том же цикле ANDоперация декодируется, и значение r10выбирается из файла регистров. Однако SUBинструкция еще не написала свой результат r10. Обратная запись обычно происходит в цикле 5 (зеленая рамка). Следовательно, значение, прочитанное из регистрового файла и переданное в ALU (на этапе выполнения ANDоперации, красный квадрат), неверно.

Вместо этого мы должны передать данные, которые были вычислены, SUBобратно на этап Execute (то есть в красный кружок на диаграмме) ANDоперации, прежде чем они будут нормально записаны обратно. Решение этой проблемы - пара байпасных мультиплексоров. Эти мультиплексоры находятся в конце этапа декодирования, и их выходы с флопами являются входами для ALU. Каждый мультиплексор выбирает между:

1. Порт чтения регистрового файла (то есть выход этапа декодирования, как в наивном конвейере): красная стрелка
2. Текущий конвейер регистров ALU (для обхода одним этапом): синяя стрелка
3. Текущий конвейер регистров этапа доступа (который является либо загруженным значением, либо перенаправленным результатом ALU, это обеспечивает обход двух этапов): фиолетовая стрелка. Обратите внимание, что для этого требуется, чтобы данные были переданы назад во времени на один цикл. В этом случае необходимо вставить пузырек , чтобы остановить ANDоперацию, пока данные не будут готовы.

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

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

Решение Б. Блокировка трубопровода [ править ]

Однако примите во внимание следующие инструкции:

LD  adr  ->  r10 И  r10 , r3  ->  r11

Данные, считанные с адреса adr, не присутствуют в кэше данных до тех пор, пока команда не завершит этап доступа к памяти LD. К этому времени ANDинструкция уже идет через АЛУ. Чтобы решить эту проблему, потребовалось бы, чтобы данные из памяти были переданы назад во времени на вход ALU. Это невозможно. Решение - отложить ANDинструкцию на один цикл. Опасность данных обнаруживается на этапе декодирования, а этапы выборки и декодирования останавливаются - они не могут сбрасывать свои входные данные и поэтому остаются в одном и том же состоянии в течение цикла. На следующих этапах выполнения, доступа и обратной записи между командами LDи вставляется дополнительная инструкция без операции (NOP) AND.

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

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

Эту опасность для данных можно довольно легко обнаружить, когда машинный код программы написан компилятором. Стэнфорд MIPS машина опиралась на компилятор , чтобы добавить инструкции NOP в этом случае, вместо того , чтобы иметь схему для обнаружения и (более taxingly) стойла первого два этапа трубопровода. Отсюда и название MIPS: микропроцессор без взаимосвязанных этапов конвейера. Оказалось, что дополнительные инструкции NOP, добавленные компилятором, достаточно расширили двоичные файлы программы, что снизило частоту попаданий в кэш инструкций. Аппаратное обеспечение, хотя и дорогое, было возвращено в более поздние разработки, чтобы улучшить процент попаданий в кэш команд, после чего аббревиатура перестала иметь смысл.

Управляйте опасностями [ править ]

Опасности управления вызваны условным и безусловным ветвлением. Классический конвейер RISC разрешает переходы на этапе декодирования, что означает, что повторение разрешения переходов длится два цикла. Есть три следствия:

• Повторение разрешения ветвлений проходит через довольно много схем: чтение кэша инструкций, чтение файла регистров, вычисление условия ветвления (которое включает 32-битное сравнение на процессорах MIPS) и мультиплексор адреса следующей инструкции.
• Поскольку цели перехода и перехода вычисляются параллельно чтению регистра, RISC ISA обычно не имеют инструкций, которые переходят к адресу регистр + смещение. Поддерживается переход к регистрации.
• При любом предпринятом переходе инструкция сразу после перехода всегда выбирается из кэша инструкций. Если эта инструкция игнорируется, на каждый взятый переход IPC накладывается один цикл , который достаточно велик.

Существует четыре схемы решения этой проблемы производительности с помощью ветвей:

• Predict Not Taken: всегда получать инструкцию после перехода из кеша инструкций, но выполнять ее только в том случае, если переход не был выполнен. Если ответвление не занято, трубопровод остается заполненным. Если переход выполняется, инструкция сбрасывается (помечается, как если бы она была NOP), и возможность одного цикла завершить выполнение инструкции теряется.
• Вероятность перехода: всегда извлекать инструкцию после перехода из кеша инструкций, но выполнять ее только в том случае, если переход был выполнен. Компилятор всегда может заполнить слот задержки ветвления в такой ветке, и, поскольку ветки выполняются чаще, чем нет, такие ветки имеют меньший штраф IPC, чем предыдущий тип.
• Слот задержки перехода : всегда выбирайте инструкцию после перехода из кеша инструкций и всегда выполняйте ее, даже если переход выполняется. Вместо того, чтобы взимать штраф IPC за некоторую долю взятых ветвей (возможно, 60%) или неиспользованных (возможно, 40%), слоты задержки ветвления принимают штраф IPC для тех ветвей, в которых компилятор не может запланировать слот задержки ветвления. Разработчики SPARC, MIPS и MC88K разработали слот задержки перехода в свои ISA.
• Прогнозирование переходов : параллельно с выборкой каждой инструкции угадывайте, является ли инструкция переходом или переходом, и если да, угадывайте цель. В цикле после перехода или перехода получить инструкцию в предполагаемой цели. Если предположение неверно, очистите неправильно выбранную цель.

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

Задержанные ветки подверглись критике ^{[ кем? ]} как плохой краткосрочный выбор в дизайне ISA:

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

Исключения [ править ]

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

Самое простое решение, предоставляемое большинством архитектур, - это арифметика с упаковкой. У чисел, превышающих максимально возможное закодированное значение, самые старшие биты обрезаются до тех пор, пока они не подходят. В обычной системе счисления 3000000000 + 3000000000 = 6000000000. При беззнаковой 32-битной арифметике обертывания 3000000000 + 3000000000 = 1705032704 (6000000000 mod 2 ^ 32). Это может показаться не очень полезным. Самым большим преимуществом арифметики обертывания является то, что каждая операция дает четко определенный результат.

Но программист, особенно если он программирует на языке, поддерживающем большие целые числа (например, Lisp или Scheme ), может не захотеть использовать арифметику с оболочкой. Некоторые архитектуры (например, MIPS) определяют специальные операции сложения, которые переходят в определенные места при переполнении, а не обертывают результат. Программное обеспечение в целевом местоположении отвечает за решение проблемы. Эта специальная ветвь называется исключением. Исключения отличаются от обычных переходов тем, что целевой адрес не указывается в самой инструкции, а решение о переходе зависит от результата инструкции.

Самый распространенный вид программно-видимого исключения на одной из классических RISC-машин - это промах TLB .

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

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

Чтобы принимать точные исключения, ЦП должен зафиксировать изменения видимого состояния программного обеспечения в порядке выполнения программы. Эта упорядоченная фиксация происходит очень естественно в классическом конвейере RISC. Большинство инструкций записывают свои результаты в регистровый файл на этапе обратной записи, и поэтому эти записи происходят автоматически в порядке выполнения программы. Однако инструкции Store записывают свои результаты в очередь данных Store на этапе доступа. Если инструкция сохранения принимает исключение, запись очереди данных сохранения становится недействительной, поэтому она не записывается в SRAM данных кэша позже.

Обработка промахов кеша [ править ]

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

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

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

Ссылки [ править ]