Самодельный процессор nedoRISC-1

Shaos · Post by **Shaos** » 21 Nov 2009 13:04

Мне тут по дешёвке перепала сотня 74F00 (аналог ЛА3 со средним временем срабатывания в 3 нс) и решил я построить свой собственный RISC-процессор - 16-разрядный и с конвейером и гарвардской архитектурой (раздельные шины данных и программ) - всё для скорости. Ширина слова данных будет 16 бит, а вот ширину слова программы я решил сделать нестандартной - 24 бита (первые 4 бита кодируют код операции, а предназначение остальных 20 битов определяется кодом операции). Имеем до 16 штук равноправных 16-разрядных регистров с названиями от R0 до R15 (причём регистр R0 всегда равен нулю и запись в него не меняет его содержимое). Адресуемое пространство в памяти программ - до 1 мегаслова. Адресуемое пространство в памяти данных - до 1 мегаслова (с переключением банков по 64 килослова). Теперь по кодам операций (старшие 4 бита кодового слова):

0000 (OP) - арифметическая или логическая операция (далее 4 бита для регистра результата, 4 бита для регистра первого аргумента, 4 бита для регистра второго аргумента, 4 бита на код подоперации над старшим байтом данных, 4 бита на код подоперации над младшим байтом данных);
0001 (JUMP) - переход на 20-битный адрес в памяти программ;
0010 (CALL) - вызов подпрограммы по 20-битному адресу (стек адресов возврата спрятан и имеет ограниченную глубину);
0011 (RET) - возврат из подпрограммы (далее 4 бита для регистра куда надо записать следующие 16 бит);
0100 (LOAD) - чтение из памяти данных в регистр (далее 4 бита для кода регистра и 16 бит на младшую часть адреса данных);
0101 (SAVE) - запись регистра в память данных (далее 4 бита для кода регистра и 16 бит на младшую часть адреса данных);
0110 (INIT) - загрузить 16-битное число в регистр (далее 4 бита для кода регистра и 16 бит на записываемое число);
0111 (COPY) - копирование с перестановкой (опишу позже);
1000 (CLR) - сбросить отдельный бит в регистре, а также записать байт в другой регистр (4 бита код регистра для сброса и 4 бита задают номер бита для сброса, далее 4 бита код регистра для записи данных и 8 бит сами данные);
1001 (SET) - установить отдельный бит в регистре, а также записать байт в другой регистр (4 бита код регистра для установки и 4 бита задают номер бита для установки, далее 4 бита код регистра для записи данных и 8 бит сами данные);
1010 (SKIP0) - проверить состояние бита в регистре и пропустить следующую команду если 0, а также записать байт в другой регистр (4 бита код регистра для тестирования и 4 бита задают номер бита для тестирования, далее 4 бита код регистра для записи данных, далее 8 бит сами данные);
1011 (SKIP1) - проверить состояние бита в регистре и пропустить следующую команду если 1, а также записать байт в другой регистр (4 бита код регистра для тестирования и 4 бита задают номер бита для тестирования, далее 4 бита код регистра для записи данных, далее 8 бит сами данные);
1100 (ILOAD) - косвенное чтение из памяти данных в регистр (далее 4 бита задают регистр куда читать, далее 4 бита задают регистр со старшей частью адреса - из него берётся только младший байт, далее 4 бита задают регистр с младшей частью адреса и следующие 8 бит задают смещение);
1101 (ISAVE) - косвенная запись регистра в память данных (далее 4 бита задают регистр откуда читать, далее 4 бита задают регистр со старшей частью адреса - из него берётся только младший байт, далее 4 бита задают регистр с младшей частью адреса и следующие 8 бит задают смещение);
1110 (TEST) - проверить состояние битов регистра по маске (далее 4 бита для кода регистра и 16 бит на маску по AND - меняется только флаг Z);
1111 (EXT) - заререзрвировано для будущих расширений.

Подробнее об арифметических и логических операциях - особенностью предлагаемого дизайна является возможность одновременно выполнять РАЗНЫЕ операции над двумя однобайтовыми половинками регистров (т.е. этот 16-разрядный процессор в каком-то смысле можно рассматривать как два 8-разрядных), причём оба аргумента и приёмник могут быть тремя разными регистрами (указывание R0 в качестве аргумента означает 0, а в качестве результата означает игнорирование результата). Коды арифметических и логических подопераций:

Code: Select all

0000 - MOV (копирование из первого аргумента);
0001 - MOV2 (копирование из второго аргумента);
0010 - INV (копирование с инверсией из первого аргумента);
0011 - INV2 (копирование с инверсией из второго аргумента);
0100 - RRC (копирование со сдвигом вправо через флаг C первого аргумента);
0101 - RRC2 (копирование со сдвигом вправо через флаг C второго аргумента);
0110 - RLC (копирование со сдвигом влево через флаг C первого аргумента);
0111 - RLC2 (копирование со сдвигом влево через флаг C второго аргумента);
1000 - NAND (логическая побитовая операция И-НЕ);
1001 - XOR (логическая побитовая операция ИСКЛЮЧАЮЩЕЕ ИЛИ);
1010 - AND (логическая побитовая операция И);
1011 - OR (логическая побитовая операция ИЛИ);
1100 - ADI (прибавить к содержимому первого регистра число, хранящееся на месте второго и сохранить результат);
1101 - SBI (вычесть из содержимого первого регистра число, хранящееся на месте второго и сохранить результат);
1110 - ADC (сложение с использованием флага C);
1111 - SBC (вычитание с использованием флага C).

Предполагаемый набор флагов:
S - sign (результат оказался отрицательным)
Z - zero (результат оказался нулевым)
V - overflow (было переполнение при сложении или вычитании)
B - borrow (было заимствование при вычитании)
C - carry (был перенос при сложении или сдвиге)
H - half carry (был перенос между байтами при сложении или сдвиге)
O - stack overflow (было переполнение стека адресов возвратов)
D - dummy flag (нулевой флаг используемый для пустых операций с битами)

Если взять R15 как способ добраться до младших 16 битов PC, то появится возможность делать интересный трюк switch/cases - либо через возврат слова в RET, либо путём дальнейшего перехода по JMP из таблицы, правда при этом необходимо, чтобы таблица, куда мы идём через непосредственную запись в R15, располагалась в том же 64К сегменте памяти, откуда был осуществлён такой переход (т.к. старшие 4 бита адреса не меняются).

Думаю сделать обращение к флагам через R14 (старшей его части) - причём там же (в младшем байте) можно держать один байт старшей части адреса данных (будет переключать банки по 64К).

И как я уже говорил выше - регистр R0 всегда будет возвращать 0, а любая попытка записи в него будет проигнорирована.

P.S. 01-11-2015: Переставил кое-какие поля. Последняя версия дизайна проца всегда будет тут: http://www.nedopc.org/nedopc/1/Core

Shaos · Post by **Shaos** » 21 Nov 2009 18:28

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

Shaos · Post by **Shaos** » 21 Nov 2009 20:32

Shaos wrote:Копирования с перестановками должны как минимум разрешать менять местами байты любого регистра - пока предполагаю что за кодом операции 0111 будет идти 4 бита кода регистра куда надо записать результат, потом два раза по 4 - регистры аргументы, а потом у нас остаётся ещё 8 бит в которые и надо затолкать код пермутации (либо это будет два 4-битных кода для старшего байта и для младшего байта - точно также как и для арифметических и логических операций).

Примерный вариант разделённых кодов для старшего и младшего байта результата:

0000 (L1) - взять младший байт из первого регистра;
0001 (H1) - взять старший байт из первого регистра;
0010 (L2) - взять младший байт из второго регистра;
0011 (H2) - взять старший байт из второго регистра;
0100 (L1B) - взять младший байт из первого регистра и переставить соседние биты;
0101 (H1B) - взять старший байт из первого регистра и переставить соседние биты;
0110 (L2B) - взять младший байт из второго регистра и переставить соседние биты;
0111 (H2B) - взять старший байт из второго регистра и переставить соседние биты;
1000 (L1P) - взять младший байт из первого регистра и переставить соседние пары битов;
1001 (H1P) - взять старший байт из первого регистра и переставить соседние пары битов;
1010 (L2P) - взять младший байт из второго регистра и переставить соседние пары битов;
1011 (H2P) - взять старший байт из второго регистра и переставить соседние пары битов;
1100 (L1N) - взять младший байт из первого регистра и переставить половинки байта;
1101 (H1N) - взять старший байт из первого регистра и переставить половинки байта;
1110 (L2N) - взять младший байт из второго регистра и переставить половинки байта;
1111 (H2N) - взять старший байт из второго регистра и переставить половинки байта.

Теперь надо понять для чего же это может пригодиться

danchandoo · Post by **danchandoo** » 22 Nov 2009 01:31

Это просто замечательно, что я вас сподвиг на такое ))
Но мне интересно, вы собираетесь создавать материальный вариант этого процессора? Если да, то не в базисе же И-НЕ -- это мазохизм, хотябы исходя из колличества необходимых вентелей. Нужно быдет применять и другие "logic gates" (как это перевести на русский?). Иначе простой статический D-триггер это 4 элемента 2И-НЕ, 15 регистров это 240 триггеров...
Если же цель -- создать RISC-процессор именно на И-НЕ, то, вероятно, это должен быть красивый минимализм, не обладающий такой монстроидальной системой комманд, и скорее выигрывающий за счет быстродействия и оптимизированного компилятора.

Shaos wrote:особенностью предлагаемого дизайна является возможность одновременно выполнять РАЗНЫЕ операции над двумя однобайтовыми половинками регистров

А на состояние флагов будет влиять результат какой из 2-х операций?
Или же флаги выставляются по общему результату? Ну например логика флага Z это позволяет, а с другими как будет обстоять дело?

Shaos · Post by **Shaos** » 22 Nov 2009 09:28

danchandoo wrote:Это просто замечательно, что я вас сподвиг на такое ))
Но мне интересно, вы собираетесь создавать материальный вариант этого процессора? Если да, то не в базисе же И-НЕ -- это мазохизм, хотябы исходя из колличества необходимых вентелей. Нужно быдет применять и другие "logic gates" (как это перевести на русский?). Иначе простой статический D-триггер это 4 элемента 2И-НЕ, 15 регистров это 240 триггеров...
Если же цель -- создать RISC-процессор именно на И-НЕ, то, вероятно, это должен быть красивый минимализм, не обладающий такой монстроидальной системой комманд, и скорее выигрывающий за счет быстродействия и оптимизированного компилятора.

да - естественно регистры и память будут не на И-НЕ

а для простого RS-триггера на самом деле достаточно двух элементов

danchandoo wrote:
Shaos wrote:особенностью предлагаемого дизайна является возможность одновременно выполнять РАЗНЫЕ операции над двумя однобайтовыми половинками регистров
А на состояние флагов будет влиять результат какой из 2-х операций?
Или же флаги выставляются по общему результату? Ну например логика флага Z это позволяет, а с другими как будет обстоять дело?

ну у нас уже есть два флага переноса - C и H (между байтами), а Z и S будут давать результат целого слова - в-принципе проверить на ноль отдельный байт - это всего лишь одна дополнительная команда (да и на знак тоже)

от флага чётности я отказался - честно говоря не вижу в нём смысла на программном уровне

ещё хотел бы посоветоваться с народом на тему отдельного флага B заёма при вычитании - у многих он совмещён с C

Shaos · Post by **Shaos** » 22 Nov 2009 09:39

исходя из того что я планирую конвейер (пока выполняется команда параллельно вычитываем следующее слово из памяти) и 70 нс ПЗУ, то скорее всего одна команда и будет выполняться за 70 нс - т.е. предельная скорость такого процессора будет 14 MIPS (по идее есть 45 нс пзухи - тогда можно будет попробовать скорость поднять до 22 MIPS) - а скоростей серии 74F00 должно хватить на реализацию нескольких тактов в пределах одной команды (я пока насчитал 5, но скорее всего будет на парочку больше - для сложных команд)

Shaos · Post by **Shaos** » 22 Nov 2009 16:08

Кстати эта архитектура "с лёгкостью" расширяется до 32-разрядной - просто добавляем ещё 8 битов в команду (сделав её более привычной 32-битной) и получаем 4 параллельных 8-битных вычислителя - правда придётся с флагами подумать - возможно их надо будет продублировать и расширить. Ну и возможности записывать полноценное 32-битное число в регистр за одну команду не будет - максимум только 24-битное. Непосредственная адресация кода увеличится до 256 Мслов, а данных - при непосредственной адресации до 16 Мслов в пределах одного сегмента при 256 сегментах (т.е. всего 4 Гслова), а при косвенной - может быть даже и больше. Кроме того будет возможность превратить существующий 16-битный код в 32-битный без перекомпиляции программы.

Shaos · Post by **Shaos** » 22 Nov 2009 20:43

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

r0 - всегда 0
r1 - глобальный регистр (никогда не сдвигается)
r2 - глобальный регистр (никогда не сдвигается)
r3 - глобальный регистр (никогда не сдвигается)
r4 - глобальный регистр (никогда не сдвигается)
r5 - исчезнет после ret или превратится в r10 после call
r6 - исчезнет после ret или превратится в r11 после call
r7 - исчезнет после ret или превратится в r12 после call
r8 - исчезнет после ret или превратится в r13 после call
r9 - исчезнет после ret как и после call (вызов подпрограммы не должен разрушать флаги)
r10 - превратится в r5 после ret или сохранится после call
r11 - превратится в r6 после ret или сохранится после call
r12 - превратится в r7 после ret или сохранится после call
r13 - превратится в r8 после ret или сохранится после call
r14 - превратится в r9 после ret или сохранится после call (флаги)
r15 - содержит младшие 16 битов текущего PC (старшие 4 скрыты)

При вызове подпрограммы регистры r5-r8 встают на место r10-r13 (при этом старые r10-r14 сохраняются вместе с адресом возврата), а на место r5-r9 встаёт следующее окно. При очередном вызове подпрограммы всё также сдвинется вниз, а при возврате - вверх. Как видно вызывающая программа может проверить флаги подпрограммы в регистре r9, в то же время получив свои сохранённые флаги в r14.

Shaos · Post by **Shaos** » 22 Nov 2009 22:42

Shaos wrote: ещё хотел бы посоветоваться с народом на тему отдельного флага B заёма при вычитании - у многих он совмещён с C

ну так что народ скажет? использовать ли C и для вычитания тоже?

P.S. почитал http://en.wikipedia.org/wiki/Carry_flag - наверное всё-таки надо иметь два различных флага, чтобы не путаться

P.P.S. теоретический вопрос - почему принято, чтобы логические операции обнуляли флаг C?

danchandoo · Post by **danchandoo** » 23 Nov 2009 00:56

исходя из того что я планирую конвейер (пока выполняется команда параллельно вычитываем следующее слово из памяти) и 70 нс ПЗУ, то скорее всего одна команда и будет выполняться за 70 нс - т.е. предельная скорость такого процессора будет 14 MIPS (по идее есть 45 нс пзухи - тогда можно будет попробовать скорость поднять до 22 MIPS)

Может я не понял задумки, но 1 команда за такт у меня, когда я об этом думал, даже за 2, не получается!
Да действительно, микрокод текущей команды может параллельно считывать из памяти следующие слова команд, тем более, что архитектура гарвардская. Но, для выполнения одной команды с АЛУ ,например, нужно ну минимум 3 такта: загрузка 1-го операнда, загрузка второго, сохранение результата. При этом внутренняя шина данных занята на 100%, и АЛУ при классической организации тоже. Конечно параллельно можно читать следующую команду, но если ей нужна шина или АЛУ, ей прейдется ждать, прежде чем начать выполняться.
Проще говоря для слогана "1 команда за 1 такт" нужно допускать параллельное ВЫПОЛНЕНИЕ (а не выполнение первой и считывание 2-й) 2-х и более команд.

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

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

Shaos · Post by **Shaos** » 23 Nov 2009 06:40

danchandoo wrote:
исходя из того что я планирую конвейер (пока выполняется команда параллельно вычитываем следующее слово из памяти) и 70 нс ПЗУ, то скорее всего одна команда и будет выполняться за 70 нс - т.е. предельная скорость такого процессора будет 14 MIPS (по идее есть 45 нс пзухи - тогда можно будет попробовать скорость поднять до 22 MIPS)
Может я не понял задумки, но 1 команда за такт у меня, когда я об этом думал, даже за 2, не получается!
Да действительно, микрокод текущей команды может параллельно считывать из памяти следующие слова команд, тем более, что архитектура гарвардская. Но, для выполнения одной команды с АЛУ ,например, нужно ну минимум 3 такта: загрузка 1-го операнда, загрузка второго, сохранение результата. При этом внутренняя шина данных занята на 100%, и АЛУ при классической организации тоже. Конечно параллельно можно читать следующую команду, но если ей нужна шина или АЛУ, ей прейдется ждать, прежде чем начать выполняться.
Проще говоря для слогана "1 команда за 1 такт" нужно допускать параллельное ВЫПОЛНЕНИЕ (а не выполнение первой и считывание 2-й) 2-х и более команд.

я же следом написал - а скоростей серии 74F00 должно хватить на реализацию нескольких тактов в пределах одной команды (я пока насчитал 5, но скорее всего будет на парочку больше - для сложных команд) - т.е. тактовая частота будет как минимум в 5 раз больше (т.е. будем иметь одну команду на 5 тактов, а не на 1 - следовательно тактовая частота процессора при этом будет от 70 до 110 МГц), просто для "1 команды за такт" надо городить как-минимум 5-ступенчатый пипелайн (причём с быстрой памятью), что может породить нежелательные побочные эффекты, как например отложенная передача управления (когда будет выполняться одна или даже две команды непосредственно идущие за JMP или CALL), невозможность использования результата предыдущей операции непосредственно следом за ней (типа R1=1 и следом R2=R1 будет брать старое значение R1) и т.д., поэтому у меня только 2 ступени - в первой читаем из медленной памяти, а во второй - по шагам выполняем уже считанную команду внутри процессора.

danchandoo · Post by **danchandoo** » 23 Nov 2009 09:32

Shaos wrote: а скоростей серии 74F00 должно хватить на реализацию нескольких тактов в пределах одной команды

Извените, я не сразу разобрался со смыслом этой фразы.

Shaos · Post by **Shaos** » 24 Nov 2009 20:12

Довожу до сведения общества анонимных почитателей данного форума следующее: ДА, я знаю о существовании быстрой ECL-логики (даже в институтские времена мечтал когда-нибудь построить на ней свой компьютер), однако сейчас я даже и не думал её использовать по очень просто причине - цена за корпус серии 10 начинается от 4.5 долларов (а за корпус серии 100 и вообще по тридцатке берут), а свои 74F00 я приобрёл по цене в 4.5 цента за корпус - т.е. ECL в 100 раз дороже, что согласитесь не стоит трёхкратного ускорения (1 нс против 3 нс).

И про AMD-шные процессорные модули я тоже знаю - вчера статью читал про них, но мне это не интересно...

И строить я это планирую не только из 74F00, но и с использованием регистров и буферов, и возможно чего-нибудь ещё...

Shaos · Post by **Shaos** » 25 Nov 2009 07:41

И кстати - о том кто и откуда сюда ходит я узнаю из реферреров, т.к. регулярно их просматриваю - например "общество анонимных почитателей" за последние три дня привело ко мне 5.48% посетителей - спасибо CHRV за подброс

Lavr · Post by **Lavr** » 14 Dec 2009 10:51

Я, возможно, несколько не в тему, но наткнулся я где-то в Инете (адрес не запомнил, а список хистори большой был...) некоторые
джентльмены спорили на 10 листах, а может и больше, сможет ли один
из них построить полноценный 8-разрядный процессор, причем в
железе, как говорится...
8080 они отмели, как сложный...
Я длинные споры просто не люблю по жизни, но ветка забавная
у них - так что прочитал...
А вопрос вот в чем - а может попробовать простой, но реально
действующий процессор сделать на логике ?
8-разрядный - ну чтобы существующее старье к нему подходило...
Мне кажется это будет интересно...

PS. не поленился - поискал и нашел всё-таки:
Спроектировать процессор «на коленке». Возможно ли?
http://balancer.ru/tech/forum/2009/06/t ... no-li.html

Самодельный процессор nedoRISC-1

Самодельный процессор nedoRISC-1

Простой процессор