4-bit Processor

Lavr · Post by **Lavr** » 05 Jul 2011 10:16

HardWareMan wrote:
Lavr wrote:А вот как, к примеру, реализовать CМP для двух байт, загруженных в четыре 4-битных регистра? Или CPI с байтом памяти?
Так же, как и делается сравнение 16бит на ВМ80 - за два захода. Сравнивай пониблово.

580ВМ80 не имеет такой отдельной команды сравнение 16 бит...
Но серьёзно - напиши, как ты представляешь сравнение двух байт в
ниббловых регистрах? Пусть мнемоники - от 580ВМ80 а регистры как
у i4004: R0, R1, R2, R3, флаги - Z C S

HardWareMan · Post by **HardWareMan** » 05 Jul 2011 10:21

Легко:

Code: Select all

ROM:C427 ; =============== S U B R O U T I N E =======================================
ROM:C427
ROM:C427 ; Cравнение HL и DE. Портит [A], выставляет флаги.
ROM:C427
ROM:C427 BIOS_HL_DE_Compare:                     ; CODE XREF: BIOS_Load_Block_Loop+6^p
ROM:C427                                         ; BIOS_Copy_HL2BC+4^p ...
ROM:C427                 mov     a, h
ROM:C428                 cmp     d
ROM:C429                 rnz
ROM:C42A                 mov     a, l
ROM:C42B                 cmp     e
ROM:C42C                 ret
ROM:C42C ; End of function BIOS_HL_DE_Compare

Возвращает результат сравнения [HL] и [DE], причем с учетом >, < или =.

В твоем ЦПУ можно сравнивать в АЛУ сразу целевые регистры, без использования аккумулятора (если есть).

Lavr · Post by **Lavr** » 05 Jul 2011 10:29

HardWareMan wrote:Легко:
Code: Select all
ROM:C427 ; =============== S U B R O U T I N E =======================================
ROM:C427
ROM:C427 ; Cравнение HL и DE. Портит [A], выставляет флаги.
ROM:C427
ROM:C427 BIOS_HL_DE_Compare:                     ; CODE XREF: BIOS_Load_Block_Loop+6^p
ROM:C427                                         ; BIOS_Copy_HL2BC+4^p ...
ROM:C427                 mov     a, h
ROM:C428                 cmp     d
ROM:C429                 rnz
ROM:C42A                 mov     a, l
ROM:C42B                 cmp     e
ROM:C42C                 ret
ROM:C42C ; End of function BIOS_HL_DE_Compare
Возвращает результат сравнения [HL] и [DE], причем с учетом >, < или =.
В твоем ЦПУ можно сравнивать в АЛУ сразу целевые регистры, без использования аккумулятора (если есть).

Тогда в таком стиле придётся записать все привычные операции с байтами.

HardWareMan · Post by **HardWareMan** » 05 Jul 2011 10:32

Lavr wrote:Тогда в таком стиле придётся записать все привычные операции с байтами.

Так, я немного не понял: мы говорим за 8ми битную арифметику на 4битном процессоре или нативную поддержку 8ми битных вычислений самим процессором? Второе по аналогии (16 бит на 8 битах) в 8080 сделано (команды DAD) за счет увеличения количество тактов команды. А у Z80 вообще есть ADC/SBC, позволяющие к тому же каскадировать 16ти битные вычисления...

Lavr · Post by **Lavr** » 05 Jul 2011 10:39

HardWareMan wrote:
Lavr wrote:Тогда в таком стиле придётся записать все привычные операции с байтами.
Так, я немного не понял: мы говорим за 8ми битную арифметику на 4битном процессоре или нативную поддержку 8ми битных вычислений самим процессором? Второе по аналогии (16 бит на 8 битах) в 8080 сделано (команды DAD) за счет увеличения количество тактов команды. А у Z80 вообще есть ADC/SBC, позволяющие к тому же каскадировать 16ти битные вычисления...

Судя по i4004, понадобится и то и другое... он очень напоминет i8080.
То есть, наш 4-битный проц должен уметь работать с байтами, если мы
не игрушку, а что-то приемлемое хотим.

HardWareMan · Post by **HardWareMan** » 05 Jul 2011 11:07

Ну тогда я с вами! Мне как раз нужен компактный супервизор в CPLD на одну платку. Разработаем проц, ассемблер к нему и будет все в шоколаде.

Shaos · Post by **Shaos** » 05 Jul 2011 11:10

HardWareMan wrote:Ну тогда я с вами! Мне как раз нужен компактный супервизор в CPLD на одну платку. Разработаем проц, ассемблер к нему и будет все в шоколаде.

Чур я пишу эмулятор и поддержку в RASM

Естественно под GPLv3 и выкладыванием исходников на SourceForge в nedoPC SDK

Lavr · Post by **Lavr** » 05 Jul 2011 11:23

Shaos wrote:для 4-битной платформы:
- можно добавить нативный целочисленный тип nibble (unsigned nibble 0...15, signed nibble -8...+7)

А как бы смоделировать реально этот тип nibble?
Вроде мы с b2m и Хардычем тонкие моменты обговорили, теперь бы попробовать...

И кстати говоря, с 8-битной памятью вырисовывается красиво как в i8086.
А0 - от РС - на мультиплексор:"Младший ниббл/Старший ниббл", остальные
адреса - на линии чипа памяти. Но это только на чтение красиво...

Shaos · Post by **Shaos** » 05 Jul 2011 13:18

Lavr wrote:
Shaos wrote:для 4-битной платформы:
- можно добавить нативный целочисленный тип nibble (unsigned nibble 0...15, signed nibble -8...+7)
А как бы смоделировать реально этот тип nibble?
Вроде мы с b2m и Хардычем тонкие моменты обговорили, теперь бы попробовать...

Тебе на С/C++ надо? Можно классы сделать с переопределёнными операторами...

Lavr · Post by **Lavr** » 05 Jul 2011 13:41

HardWareMan wrote:Разработаем проц, ассемблер к нему и будет все в шоколаде.

Ну тогда всё получается по первоначальному плану: делаем быстрый чисто
4-битный RISC-процессор сугубо со своей системой команд.
Используем 2 префикса - и получаем 46 инструкции. Вполне хватит, чтобы
сделать её чуть удобнее чем у PIC-а.

Я немного смутился с 8-битной памятью, но поскольку у RISC-а память
программ - только на чтение, понибблово она читаться будет легко.
А загружать её будем через аппаратный SPI - байтами, обсудили уже...

Единственное - нам нужен не обычный ассемблер, а некий кросс-ассемблер.
Поскольку в нибблах работать неудобно и непривычно, то в ассемблере мы
пишем всё в привычных байтах, ну типа:

Code: Select all

CMP C,B; где C и B - размером в байт

а наш кросс-ассемблер превращает это примерно в следующее:

Code: Select all

                 mov     R1, R3 
                 cmp     R5 
                 rnz 
                 mov     R0, R2 
                 cmp     R4 
                 ret

где R0,R1 - Alow, Ahigh; R2,R3 - Clow, Chigh; R4,R5 - Blow, Bhigh,
а R0,R1,R2,R3,R4,R5 - наши ниббловые регистры.

Аналогично кросс-ассемблер компилирует и остальные байтовые команды.

К внешним устройствам обращаемся байтами - по два обращения ниббловыми
регистрами в 2-а 4-битных регистра, причем только после второго обращения
даём строб внешнему устройству.

Ну примерно вот так всё. Хорошо, что всё 4-битное: АЛУ не "распухнет".
Систему команд обсуждали уже, но продумать надо ещё...
Мне кажется удобные префиксы - 0Eh и 0Fh, поскольку селектор на 0Eh, он
0Fh уж точно отловит, а остальные 14 (0h - 0Dh) - просто команды.

Lavr · Post by **Lavr** » 05 Jul 2011 13:45

Shaos wrote:
Lavr wrote:
Shaos wrote:для 4-битной платформы:
- можно добавить нативный целочисленный тип nibble (unsigned nibble 0...15, signed nibble -8...+7)
А как бы смоделировать реально этот тип nibble?
Вроде мы с b2m и Хардычем тонкие моменты обговорили, теперь бы попробовать...
Тебе на С/C++ надо? Можно классы сделать с переопределёнными операторами...

А на ассемблере - никак? Это было бы удобнее. То есть - мне бы уже
хотелось смоделировать это на ПиСи - но как-то нибблы маской чтоль
обрубать у байтов? Флаг С опять-же как ловить? Он же АС теперь по
сути?

Shaos · Post by **Shaos** » 05 Jul 2011 14:10

т.е. опкоды таки 4-битные? при наличии 8-битной памяти оно как-то некошерно...

Lavr · Post by **Lavr** » 05 Jul 2011 15:57

Я внимательно посмотрел на схему прототипа, размышляя как наш план реализовать,
и пришел к неожиданному выводу, что единственный наш выигрыш от полностью 4-битной
схемы - это упрощение схемотехники АЛУ примерно вполовину по числу корпусов.
Остальные детали у нас уже априори 8-битные даже в убогом прототипе.

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

Lavr wrote:пишем всё в привычных байтах, ну типа:
Code: Select all
CMP C,B; где C и B - размером в байт
а наш кросс-ассемблер превращает это примерно в следующее:
Code: Select all
                 mov     R1, R3 
                 cmp     R5 
                 rnz 
                 mov     R0, R2 
                 cmp     R4 
                 ret
где R0,R1 - Alow, Ahigh; R2,R3 - Clow, Chigh; R4,R5 - Blow, Bhigh,
а R0,R1,R2,R3,R4,R5 - наши ниббловые регистры.

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

Единственная трудность - надо аккуратно продумать аппаратные операции с флагами.
И тут есть красивый момент: к примеру, при сложении байт - складываем младшие
нибблы и флаг С - как раз будет АС. А складывая старшие нибблы - АС подаём на
вход Сin АЛУ, а Cout в этот раз и будет реальный Сarry. Возможно по этой причине
у Z80 и возникает разница с i8080 по интерпретации инструкции DAA с учётом АС?

Флаг S - фиксируем старший бит при операции со старшими нибблами.
Флаг Z - Zlow фиксируем при операции с младшими нибблами, а потом выполняем Zlow
"И" Zhigh (при операции со старшими нибблами) = Z.
Флаг Р - по аналогии с Z, если он нам вообще нужен.

Аппаратно затраты практически одинаковы, но гораздо меньше проблемм с ниббловыми
операциями программно - 4-битное АЛУ сделает их незаметно и аппаратно, а внешне -
будет удобный и привычный 8-битный интерфейс.

Я очень не хотел дополнительных мультиплексоров, но раз уж без них не обойтись,
логичнее поставить их возле 4-битного АЛУ и упростить себе работу при равных
аппаратных затратах?

Shaos · Post by **Shaos** » 05 Jul 2011 19:11

Lavr wrote: А на ассемблере - никак? Это было бы удобнее. То есть - мне бы уже
хотелось смоделировать это на ПиСи - но как-то нибблы маской чтоль
обрубать у байтов? Флаг С опять-же как ловить? Он же АС теперь по
сути?

Ну берёшь любой макроассемблер, пишешь кучу макросов и вперёд

HardWareMan · Post by **HardWareMan** » 05 Jul 2011 21:05

А зачем еще одна пара регистров? У нас будет настоящий аккумулятор? Мы либо делаем все регистры равноправными (и алу должно уметь принимать любые два регистра как вход, и любой один как выход), либо делаем один регистр аккумулятором и все действия АЛУ делает между аккумулятором и регистром.

Ну и простая схемка, реализованная в быстром CPLD как раз может нормально обогнать текущие Z80/i8080 по производительности над 8ми битными числами. :3