x80 - RISC-ядро с интуитивной системой команд для x80-CISC [Архив] - Speccy

Радио-86РК

18.05.2020, 17:26

Eсли x80 (https://zx-pk.ru/threads/31789-x80-cisc-uzhe-ne-i8080-eshchjo-ne-i8086.html) мною разрабатывается долго и нудно как CISC с системой команд интуитивного кодирования, то данный здесь процессор представляется RISC-архитектурой со «сквозным интуитивным» набором команд.

Процессор выполнен в русле акына - «что вижу, то имею» - WYSYWYG на уровне байт-кода. Тем самым, для программирования на нём не нужен никакой транслятор.

Система команд
0x00 означает HLT (как и в x80)
0x01…0x09, 0x10…0x19, 0x20…0x29, 0x30…0x39, 0x40…0x49, 0x50…0x59, 0x60…0x69, 0x70…0x79, 0x80…0x89, 0x90…0x99 - непосредственный двоично-десятичный операнд 1…99, заносимый в текущий аккумулятор двоичной величиной 0x01…0x63
0x0A - ADD; 0x0B - SUB; 0x0E - EOR
0x0C - AND (Conjunction)
0x0D - OR (Disjunction)
0x0F - CMP (Flags)
0xA1…0xA9 - выбор индекса регистра A (A₁…A₉)
0xB1…0xB9 - выбор индекса регистра B (B₁…B₉)
0xC1…0xC9 - выбор индекса регистра C (C₁…C₉)
0xAA / 0xAB / 0xAC - выбор группы операндов: A,A; A,B; A,C
0xBA / 0xBB / 0xBC - выбор группы операндов: B,A; B,B; B,C
0xCA / 0xCB / 0xCC - выбор группы операндов: C,A; C,B; C,C
0xAD - занесение значений операндов в регистр адреса ADdress
0xBE - извлечение данных из буфера (Buffer Extract: register = [ADdress])
0xBF - заполнение буфера данными (Buffer Fill: [ADdress] = register)
0xCF - инверсия флага CF (Carry Flag)
0xD0 - метка цикла DO (ADDR = IP)
0xDA / 0xDB / 0xDC / 0xDD / 0xDE / 0xDF - условное выполнение (Do if Among / Bigger / Carry / Discarry / Equal / Fiction)
0xEB - переход на адрес (Execute Buffer pointed by ADdress)
То есть, как и в x80, здесь та же самая концепция: Какими символами машинный код кодируется, такая и аббревиатура команды.
Практически, это и есть вся система команд!
(Инструкция EB комбинированная: Вместе с переходом на ADdress, она помещает адрес возврата в ADdress. А так как этот регистр доступен только на запись командой AD, то сбрасываются индексы регистров на B₀ и C₀, через которые можно и прочитать регистр ADdress.)

Например, такая программа:
// Исходный код
*(BYTE *)0x76D0 = '*';

// Промежуточный код
*(BYTE *)MAKEWORD(0xD0, 0x76) = 0x2A;

// Развёрнутый код
*(BYTE *)(AD = MAKEWORD(B8 = 52 << 2, A9 = 59 << 1)) = (A1 = 40);кодируется таким дампом:
.0 .1 .2 .3 .4 .5 .6 .7 .8 .9 .A .B .C .D .E .F
0000 A9 B8 AA 59 0A BB 52 0A 0A AB AD A1 40 BF 00 ..И по байтам её можно представить вот так:
0000 A9 : A₉ ; Using A#9
0001 B8 : B₈ ; Using B#8
0002 AA : A₉,A₉ ; Reciever A#9, Translator A#9
0003 59 :SET A₉,59 ; Load 59 to receiver A#9
0004 0A :ADD A₉,A₉ ; A₉=118=0x76
0005 BB : B₈,B₈ ; Receiver B#8, Translator B#8
0006 52 :SET B₈,52 ; Load 52 to receiver B#8
0007 0A :ADD B₈,B₈ ; B₈=104=0x68
0008 0A :ADD B₈,B₈ ; B₈=208=0xD0
0009 AB : A₉,B₈ ; Hi-Byte A#9, Lo-Byte B#8
000A AD :ADR A₉,B₈ ; ADDR=MAKEWORD(B₈,A₉)
000B A1 : A₁ ; Receiver A#1
000C 40 :SET A₁,40 ; A₁ = 0x2A = '*'
000D BF :BF A₁ ; Buffer Flush
000E 00 :HLT ; HaltНиже в архиве исходные файлы для LogiSim.
У кого симулятора нет - снимок схемы.
(Сначала я начал писать JavaScript-эмулятор. Но идея задуманного процессора показалась настолько простой, что вместо часов писанины в Блокноте я потратил недели в LogiSim и остался доволен.
Потому, могу огорчить далёких от электроники пользователей: Эмулятора нет, так как занимаюсь эмулятором x80 (https://zx-pk.ru/threads/31789-x80-cisc-uzhe-ne-i8080-eshchjo-ne-i8086.html) и нет сил заниматься другими проектами! Хотя если я решу таки строить x80 на RISC-ядре, то эмулятор данного простейшего дружелюбного процессора войдёт в состав эмулятора.)

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

Регистровый файл выполнен максимально развёрнуто из трёх дешифраторов и 27 регистров. Опять таки, можно было просто использовать готовые микросхемы памяти, но это было скучно и хотелось сделать максимально развёрнутый вариант процессора, где всё элементарно, понятно и просто, где каждый регистр подсвечивается лампочкой и может иметь отдельную шину данных для управления каким-нибудь устройством.
То есть, если собрать данный процессор собачником на ТТЛ-рассыпухе, то можно сократить размер регистрового файла и регистр C7 использовать драйвером двигателей, а регистр B6 заменить джойстиком!

Дешифратор команд выполнен так, чтобы обойтись одним вентилем 3-ИЛИ на команду. Тем самым, система команд легко наращивается программированием ПЗУ с добавлением любой группы команд в любой участок таблицы. Всего можно закодировать 24 различные группы команд. В схеме используется лишь 12.
Особенностью системы команд является именно сквозное смысловое кодирование, где шестнадцатеричное представление команды напоминает аббревиатуру команды. Если бы ни стремление достичь этого, данную схему я бы просто не взялся разрабатывать!
Это нужно понимать, если решите добавлять свои команды/!\

Была идея добавить ещё группу команд - 0x1A…0x1F, 0x2A…0x2F, 0x3A…0x3F, … … … … …, 0x9A…0x9F.
Они могут служить для повышения гибкости АЛУ-операций, где цифра выбирает индекс регистра-источника.
Например, сейчас нельзя выполнить сложение двух регистров одной группы, типа «ADD A₆,A₁».
Чтобы разрешить данные операции, можно было бы закодировать эту инструкцию кодом 0x1A: 0xAA 0xA6 0x1A.
Но, это требует добавления дополнительных мультиплексеров и усложняет схему.
А так как данная схема выполнена в стиле простоты и минимализма, то данной группы операций в ней не предусмотрено.

P.S.: Тем самым, как автор CISC-системы команд с эстетическим расположением инструкций, я реализовал и RISC-вариант с эстетическим набором команд.
Это я к тому, что и простое можно сделать красивым, не уродуя таблицу команд в угоду каких-то аппаратных издержек.
И на ТТЛ-макетке такой процессор можно собрать при практическом желании.

Радио-86РК

23.05.2020, 09:19

Пoлностью перерисовал всю схему с нуля, потратив трое суток.

Теперь, вся схема чётко разбита на разные узлы.
«Регистровый файл»: Содержит 30 РОН, среди которых 3 особых
«Выборка кода/данных»: Считывает код команды, считывает/записывает данные
«Дешифратор Команд»: Пока декодирует 10 разных групп команд
«АЛУ»: Совершает 5 действий
«Условный блок»: Пропускает следующую команду, если условие ложноСистема команд чуточку изменилась, утратив адресную команду «AD» и «CMP», но АЛУ-операции напрямую индексируют источник.

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

Теперь A₀ хранит флаги статуса АЛУ.
А регистры B₀ и C₀ хранят старший и младший байты соответственно, где B₀ - Base, C₀ - Counter.
Теперь, двоично-десятичные числа 1…99 не просто помещаются в активный регистр, а дополняют его через сложение.

Например, такие трюки:
AA A5 5E 6E :MOV A5,A6 - 8 тактов
---------------------------
AA :USE A ,A
A5 :USE A5,A5
5E :XOR A5,A5
6E :XOR A5,A6

BB B7 7E 85 85 85:MOV B7,255 - 12 тактов
----------------------------
BB :USE B ,B
B7 :USE B7,B7
7E :XOR B7,B7
85 :ADD B7,85
85 :ADD B7,85
85:ADD B7,85Схема выполнена в максимально синхронном стиле и визуально получилась достаточно красивой!

P.S.: Тем самым, я убедился, что система команд может быть интуитивно прозрачной, простой и вполне достаточной!

Радио-86РК

25.05.2020, 16:16

Всe эти дни я усердно работал над своим RISC-процессором.
Упростил его до предела в рамках выбранной концепции.
Теперь основных групп команд сократилось до девяти, включая группу АЛУ.

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

Тем самым, процессор теоретически пригоден для построения любого автомата, типа «Ну, Погоди! (https://ru.wikipedia.org/wiki/%D0%9D%D1%83,_%D0%BF%D0%BE%D0%B3%D0%BE%D0%B4%D0%B8 !_(%D1%8D%D0%BB%D0%B5%D0%BA%D1%82%D1%80%D0%BE%D0%B D%D0%BD%D0%B0%D1%8F_%D0%B8%D0%B3%D1%80%D0%B0))», «Тетриса (https://ru.wikipedia.org/wiki/Brick_Game)» или «Лунохода (https://ru.wikipedia.org/wiki/Big_Trak#%D0%AD%D0%BB%D0%B5%D0%BA%D1%82%D1%80%D0%B E%D0%BD%D0%B8%D0%BA%D0%B0_%D0%98%D0%9C-11)».

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

------------------------------------------------------------------------------
|Код команд / диапазоны|Группа |Описания, замечания, комментарий
-----------------------|----------|-------------------------------------------
00 |HLT |Прекращение счёта указателем команд IP
01-99 |ADD Ri,BCD|Двоично-десятичное накопление в регистр
0A-9F |ALU Ri,Tk |Операция АЛУ с комбинацией аргументов
A0-A9 B0-B9 C0-C9 D0-D9|REG Rn |Установка индекса активного регистра группы
AA-AD BA-BD CA-CD DA-DD|ARG Ri,Tj |Выбор комбинации аргументов операциям АЛУ
AE BE CE DE |EXT Ri |Экстракция данных из внешнего ОЗУ в регистр
AF BF CF DF |FIX Ri |Фиксация значения регистра во внешнее ОЗУ
E0-E7 |EX0-7 |Переход на адрес 0xE000-0xE700
E8-EF |Ecnd |Выполнение следующей команды по условию
F0 |FIN |Завершение с переходом на адрес Базы:Счёта
F1-FF |FN1-15 |Переход на адрес 0xF000-0xFF00
------------------------------------------------------------------------------
(n - устанавливаемый индекс, указанный битами команды)
(i или j - индекс, установленный раннее)
(k - индекс регистра временно берётся из старшего ниббла кода команды)

Группы регистров A0-A9, B0-B9 и C0-C9 составляют внутренний регистровый файл с
безусловным доступом к ним на программном уровне. Регистры B0-B9 хранят "Базу"
для обращения к памяти блоком в 256 байт, а регистры C0-C9 - счёт байта блока.
Инструкция с кодом F0 помещает текущий адрес указателя инструкций из IP в B0 и
C0, а значения из Bi и Cj помещает в IP, производя переход на адрес Bi:Cj. Тем
самым, можно обращаться к коду подпрограмм и знать адрес возврата через B0:C0.

Группу регистров D0-D9 составляют внешние Device-устройства с непосредственным
использованием в качестве операндов. Не рекомендуется активно использовать эту
группу в любых вычислительных действиях, так как нет гарантии работы программ.

Lethargeek

25.05.2020, 20:23

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

Радио-86РК

25.05.2020, 21:51

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

Так что, считаю, что у меня RISC-идеология никак не пострадала.
И уверен, что в рамках LogiSim этот процессор один из самых функциональных, представленный одной целостной схемой из стандартных примитивов.
пока вижу единственный вероятный плюс - получился бы в железе простым, возможноПо моим предварительным подсчётам… буферов ЛП11 - более 100 штук
регистров ИР23 - более 40 штук
вентилей ЛА3 - более 30 штук
мультиплексеров КП11 - около 20 штук
мультиплексеров КП2 - около 25 штук
дешифраторов ИД10 - около 10 штук
прочей логики - более 10 штук…Итого, порядка 250 корпусов…
В принципе, не так уж и много получается…
(Учитывая то, что регистровый файл можно и не реализовывать целиком, но это скажется на программной гибкости…)

Интересно было бы в Proteus'е всё это дело исполнить и там всё поточнее будет.
Да и печатные платы развести можно.

Прошу не забывать, что основная особенность процессора в том, что набор команд размещается в таблице не в стиле Пикассо (куда кистью ляпнул - тот код и дал), а с максимальным смысловым кодированием!

Кстати, так как группа команд с кодами E0…E7 и F1…FF совершают прыжки в стиле i8080-RST (адрес подпрограммы кодируется самим кодом команды: E0 прыгает на E000), то когда я исключал HLT-команду как таковую и перенёс в группу RST, сначала хотел задать ей адрес F000. Но потом подумал, что переход на 0000 - тоже не плохо.
Потому сейчас код по 0000 сначала проверяет адрес возврата в регистрах B0:C0 и если это был прыжок откуда-то, то работает как HLT - бесконечный цикл.
Тем самым, стековые макрокоманды написать можно и нормальные CALL/JMP по адресам E000…FF00.

P.S.: Думаю, процессор в целом получился «простым, но не тупым» и пройдёт тест Тьюринга.
Учитывая, что лет 10 назад у меня не хватило бы опыта на подобное…

Lethargeek

25.05.2020, 23:26

Сaму схему в симуляторе хоть запускали?
А то получается как книжку повертеть так-сяк, да картинки пролистнуть.
никакой симулятор запускать не надо, чтобы понять, что, например, вот это -

A0-A9 B0-B9 C0-C9 D0-D9|REG Rn |Установка индекса активного регистра группы
AA-AD BA-BD CA-CD DA-DD|ARG Ri,Tj |Выбор комбинации аргументов операциям АЛУ
- никакие по сути не команды, это ПРЕФИКСЫ, сами по себе никакой работы не выполняющие и аналогичные XY-префиксам Z80

Когда я впервые столкнулся с RISC'ами, то не понимал, за что их хвалят. Так как за 1 такт они выполняют по одной инструкции и для выполнения CISC-эквивалента потребуется пусть 5 инструкций, хотя та же CISC инструкция кодируется одним кодом и требует те же 5 тактов.
широко распространённое ЗАБЛУЖДЕНИЕ, не подтверждаемое на практике - всё зависит от конкретной реализации
так, в среднем плотность кода ARM2 аналогична таковой у 386, но производительность на одинаковой частоте выше вдвое
легко можно подобрать пример армокоманды, полным аналогом которой на x86 будет сразу несколько cisc-команд
у рисков обычно намного меньше режимов и способов адресации, но в вычислительных командах больше работы

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

Радио-86РК

26.05.2020, 00:40

никакой симулятор запускать не надо, чтобы понять, что, например, вот этоИ это приятно слышать! Машинный код понятный каждому!:v2_dizzy_punk:

никакие по сути не команды
всё зависит от конкретной реализации
да там ею попросту и не пахнет
целью риска было - упрощение работы конвейераНу, не станете же спорить, что данный процессор можно реализовать немного сложнее, чтобы считывались 32-битные слова и конвейером за один такт выполнялась та же группа «AB_A1_3D» как целая «OR A1,B3»?
Думаю, ещё десять лет теории да практики и реализовать это вполне возможно…

Как я это вижу?
Использовать сразу несколько ПЗУ с кодированием дополнительных бит для связи в цепочку, чтобы в 32-битном слове одно ПЗУ выделяло префикс «AB» и переключало мультиплексоры операндов, другое ПЗУ должно выделить «A1» и переключить индекс, а уж «3D» задействует АЛУ с дизъюнкцией и сохранением результата.
В принципе, это можно и сейчас реализовать, выбросив регистры хранения индексов и операндов, подключив их напрямую к шинам разных ПЗУ: Если какое-то из ПЗУ выделило префикс индекса в слове, то именно эта часть слова направляется мультиплексером на шину индекса.
Потом задача ещё состоит в том, на сколько октетов нужно сдвинуть 32-битное слово кода для подгрузки новой команды. Тут с прошивками всех ПЗУ придётся здорово повозиться! А это уже ненужное чрезмерное усложнение всей схемы в целом и концептуально…

P.S.: Ещё раз акцентирую: Процессор с интуитивно прозрачной системой команд набросал. И в качестве ядра под мой x80 (https://zx-pk.ru/threads/31789-x80-cisc-uzhe-ne-i8080-eshchjo-ne-i8086.html) он вполне подходит по тем же интуитивно идеологическим принципам. А если команда «NOP» будет занимать тысячу и один такт - это издержки реализации, а не концепции.
(Если аккуратно вскрыть тот же Core-i7 и перепрошить всё ядро под разбор моих x80-команд, то вместо гадких и противных x86-инструкций смогут выполняться мои по миллиарду за раз! Это ещё с i486 стало возможным, если отказаться от поддержки x86-кода…)

Lethargeek

26.05.2020, 01:19

Ну, не станете же спорить, что данный процессор можно реализовать немного сложнее, чтобы считывались 32-битные слова и конвейером за один такт выполнялась та же группа «AB_A1_3D» как целая «OR A1,B3»?
32 это через край, но для риска на полноценную команду без префиксов надо 16 минимум
(и это даже смысл имело на 8-битной шине в 80-е, если фетч выполнять в режиме page-mode в стиле zx-юлы)
зато сразу и кодирование проще, и куча РОН без всяких специальных "групп", и в ассемблере писать приятнее и понятнее

Ещё раз акцентирую: Процессор с интуитивно прозрачной системой команд набросал.
а что такое "интуитивная прозрачность" - не объяснил (дальше - хлеще, "интуитивно идеологический (wtf?) принцип")
первый раз такие сочетание наблюдаю, смысла как у "громкой температуры" какой-нибудь :v2_wacko:

может быть, в виду имелась "интуитивно ПОНЯТНАЯ система команд"?
но понятность именно системы команд мало от кодирования зависит

Радио-86РК

26.05.2020, 01:38

32 это через край, но для риска на полноценную команду без префиксов надо 16 минимумТo есть кодировать так:
cccrriiiittjjjj
110010001100010 EOR D1,A2Чтобы опять париться с переводом сигнатур регистров и индексов в бинарный вид, а из него - в шестнадцатеричный? Так ведь подобных архитектур в свете пруд пруди!:v2_dizzy_facepalm:
Именно «один байт - одна команда» и без всяческих битовых полей меня привлекла как концептуальная идея.

первый раз такие сочетание наблюдаю, смысла как у "громкой температуры" какой-нибудьКогда чайник кипятят на плите большим пламенем, иногда говорят «чё так орёт‽»…:v2_blink:
но понятность именно системы команд мало от кодирования зависитПо плохой традиции инженеров - да!
А ведь первые научные инструменты и живописью расписывали (пруф (https://upload.wikimedia.org/wikipedia/commons/thumb/a/a7/Old-microscopes.jpg/220px-Old-microscopes.jpg)). А ныне и параболическую антенну как поднос не расписывают, иначе бы крыши домов красивее бы смотрелись!

Вот я и сделал шаг вперёд к искусству…
Что плохого? Работает и прозрачно для интуитивного понимания и кодирования. Можно бить код вслепую, без шпаргалок…

Lethargeek

26.05.2020, 02:06

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

Когда чайник кипятят на плите большим пламенем, иногда говорят «чё так орёт‽»…
правильно, про чайник же говорят (то есть объект, у которого есть такое свойство - издавать звуки)

Что плохого? Работает и прозрачно для интуитивного понимания и кодирования. Можно бить код вслепую, без шпаргалок…
не работает, без шпаргалок запросто накосячишь, надо помнить весь контекст для команды
что находится в регистрах - неочевидно, с чем работает алу после перехода - неочевидно...
а уж читать потом всё это и и понимать... не brainfuck, но что-то общее ощущается :D

Радио-86РК

26.05.2020, 11:36

не brainfuck, но что-то общее ощущаетсяНижe в архиве моя версия Befunge к его 25-летию (нажать там File/Demo).

не работает, без шпаргалок запросто накосячишь, надо помнить весь контекст для командыОткудa такая привередливость?
Процессор по-любому требует минимальных элементарных знаний о нём. А у данного - порог вхождения меньший, чем у остальных.
Или же нужен процессор блондинки с системой команд «О'кей, процессор, как заказать пиццу?»:v2_tong:

что находится в регистрах - неочевидно, с чем работает алу после перехода - неочевидно...Меня это тоже напрягало одно время, но потом я пришёл к выводу, что любая правильная подпрограмма должна в первую очередь определиться с регистрами, а не собачить АЛУ-операции с бодуна!

P.S.: Кстати, сейчас проснулся и подумал, что неплохо было бы кодами 02…09 загружать некий счётчик Fetch-блока, который будет блокировать выборку инструкции на 2…9 тактов.
То есть код «07 1A» растянется до «07 1A 1A 1A 1A 1A 1A 1A» и можно производить сложение 7 раз за 7 тактов…

hitomi2500

26.05.2020, 19:26

Lethargeek

26.05.2020, 19:28

Откудa такая привередливость?
Процессор по-любому требует минимальных элементарных знаний о нём.
держать в голове состояние (даже разные возможные состояния) процессора в каждой строчке - это явно за пределами "минимальных"

Или же нужен процессор блондинки с системой команд «О'кей, процессор, как заказать пиццу?»
нет, такой, где достаточно будет помнить, что в процедуре в R1 у нас икс, а в R3 игрек, и не забивать себе голову лишним "выбором" и "установкой" самих регистров

P.S.: Кстати, сейчас проснулся и подумал, что неплохо было бы кодами 02…09 загружать некий счётчик Fetch-блока, который будет блокировать выборку инструкции на 2…9 тактов.
То есть код «07 1A» растянется до «07 1A 1A 1A 1A 1A 1A 1A» и можно производить сложение 7 раз за 7 тактов…
эээ, зачем вообще 7 одинаковых сложений за 7 (на самом деле больше) тактов? это сдвиг младшего бита в старшую позицию штоле? вместо and + одна прокрутка вправо...

Радио-86РК

26.05.2020, 22:25

Идея сама по себе интересная, но в вашей реализации непрактичная. Запоминать каждую контекстную расшифровку первых 6 букв алфавита - это не сильно проще чем учить опкоды классических восьмибитников (для B у вас уже в первом посте SUB, Bigger и Buffer).Этo издержки языковых барьеров и технологий.

А правило довольно простое и описывается в несколько строчек:
00 HLT - Формальный останов: Переход на 0000
nn ADD Ri,BCD - Приращение двоично-десятичной константы
na alu Ri,Tn - Операция АЛУ над Приёмником с Источником
Ri USE Ri - Выбор Индекса в группе Регистров
RT USE Ri,Tj - Выбор операндов для АЛУ-операций
RE EXT Ri - Экстракция (чтение) данных из памяти
RF FIX Ri - Фиксация (запись) результата в память
Eo Eo - Переход на адрес Eo00: E000..E700
Ec Ecnd - Условное выполнение: Execute by condition
F0 FO - Завершение Функции: Function Over
Fh Fh - Вызов Функции по адресу Fh00: F100..FF00где
R - Приёмник (Receiver)
T - Источник (Translator)
c - Индекс условия
h - Шестнадцатеричная тетрада, отличная от нуля
i - Десятичный индекс регистра. Если является частью кода - обновляется
j - Десятичный индекс регистра-источника, выбранный раннее
n - Десятичный индекс регистра-источника, используемый временно на период операции
o - Восьмеричный индекс

cnd=F - False / NE / NZ - Фальш, не Ноль
cnd=E - Equal / E / Z - Истина или Ноль
cnd=D - Dry / NC - Сухой результат без Переноса
cnd=C - Carry / C - Перенос
cnd=B - Bigger / NS - Бит Знака сброшен, результат Больше нуля
cnd=A - Among / S - Число было среди интервала
cnd=9 - / PE - Чётный паритет (просто запомнить, так как операция редко используется)
cnd=8 - / PO - Нечётный паритет (просто запомнить, так как операция редко используется)

alu=A - Add
alu=B - suB
alu=C - Conjunct (and)
alu=D - Disjunct (or)
alu=E - Exclusive or (Eor / xor)Просто, документации нормальной я не составил, так как у меня туго с изложением технических тонкостей в гуманитарном стиле.
(Я ни раз здесь подчёркивал, что процессор этот именно для хардкоршика и фаната дампов, но система команд - гуманитарно-интуитивная. Не стоит думать, что система команд для гуманитариев. Просто она такая, как именно мне удобна. Я её за уши подтягивал к гуманитарному виду, при этом оставаясь в нище хардкорщика. И она выглядит так, как представляется мною в идеале…)
Плюс резервировать опкоды под десятичные константы тоже странно - самые часто используемые константы это 0, +1 и -1, остальные излишни мне кажется.А Befunge/BrainF*ck мало? Ещё и WhiteSpace есть, который аппаратно тоже можно реализовать как процессор для блондинок: Каждая строчка - стих!
Поэтому надо смотреть на более серьёзные синтетические языки с коротким словом и малым числом букв.И это я делал, даже в Verilog'е описывал что-то. Процессор использует ПЗУ на 2 Кб, где закодировано, как реагировать на ASCII-символ.
Например, «1scrn = 1keybd + (128 - 0x80)» аппаратно переваривает как «1 байт ячейки scrn загрузить 1 байтом ячейки keybd с выражением».
То есть, первые цифры формируют режим доступа, буквами кодируется адрес, а знаками - управляется АЛУ и пр…
Можете не верить, но я занимался вопросом аппаратной реализации такого процессора.
Причём, даже находил способ чтения имени ячейки «keybd» за 1 такт через чтение 64-битного слова и каскадом ПЗУ с обратной связью, чтобы сформировать цепь букв и определить длину.
В LogiSim такое будет слишком сложно строить!
эээ, зачем вообще 7 одинаковых сложений за 7 (на самом деле больше) тактов? это сдвиг младшего бита в старшую позицию штоле? вместо and + одна прокрутка вправо...Реализовал, но схема получилась чуть путанее…
Нужно ещё перераспределить блоки графически, так как я ошибочно расположил АЛУ у выхода с регистрового файла чисто из соображений «два операнда входит - один результат выходит».
На деле же это оказалось большой ошибкой, так как именно из регистрового файла выходит несколько каналов с данными, но на входе - очень много управляющих сигналов!

Теперь коды 02…09 загружают регистр повтора. Сдвиговый регистр пропускает первый цикл и несколько раз начинает со второго цикла. Тем самым, операции с доступом к памяти с циклами 3 и 4 работают.
Интересно получилось с инструкциями E8…EF - условным выполнением: В таком режиме цикла разрешается счёт указателя команд, но не происходит выборки. Тем самым, по условию можно пропустить несколько инструкций. Например:
0000 AA A1 1E |EOR A1,A1 ; Очистить A1
0003 05 EF |EF 5 ; Условное исполнение инструкций до пятой, как «IF !ZF THEN ON N GOTO 5,6,7,8,9»
0005 A1 A2 A3 A4 | - - - ; Эти инструкции игнорируются
0009 A5 |USE A5 ; Здесь счётчик игнора очищается
000A 03 85 |REP3(A5+85) ; Здесь три раза прибавится 85Тем самым, появились такие трюки, как «ленивое выражение».
Даже если сейчас на меня обрушится куча критики, скажу, что в схеме это почти ничем существенным не усложнилось. За то программный уровень намного упростился!

AlexG

26.05.2020, 23:30

А не проще написать свой язык "асм/яву" на нужном языке, а потом транслировать в машкод?
Пример:

Начало:
Записать в Рег1 число 5
Записать в Рег2 число 10
Сложить в Рег3 Рег1 и Рег2
Конец:

В маш коде
0x15 0x05
0x16 0x0a
0x30

какой ляд мучит извилины безумными последовательностями байт ?

Радио-86РК

27.05.2020, 00:08

А не проще написать свой язык "асм/яву" на нужном языке, а потом транслировать в машкод?
A Вы точно знакомы с соседней темой (https://zx-pk.ru/threads/31789-x80-cisc-uzhe-ne-i8080-eshchjo-ne-i8086.html)?
Там хоть код тоже интуитивно понятный (если действительно заинтересован человек вникнуть), но есть всё: Эмулятор, ассемблер, дизассемблер и отладчик с поддержкой точек приостановки…
Пример:
………
В маш коде…Даже контр-заинтересованный участник пишет (https://zx-pk.ru/threads/31817-x80-risc-yadro-s-intuitivnoj-sistemoj-komand-dlya-x80-cisc.html?p=1065149&viewfull=1#post1065149)
никакой симулятор запускать не надо, чтобы понять, что, например, вот это -А вот эти «15 05 16 0A 30» как-то в уме не ложатся в «R1=5, R2=10, R3=R1+R2»…
Для сравнения, у меня это будет код «(AA A1 1E 05 01) (A2 2E 10) (A3 3E 1A 2A)»…
(Напомню, первая схема процессора кодом «AA A1 05» и отрабатывала как «A1=5». Но теперь - как «A1+=5»…)

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

Подчёркиваю: Я с чистого листа наработал систему команд в течении нескольких лет в уме, так как даже эмулятор не пытался писать. А когда скачал LogiSim и решил опробовать его возможности, набросал схему этого процессора и внёс коррективы в систему команд. То есть, самого описания команд нет, так как всё в голове и на схеме. Лишь на днях в HTML набросал примитивный дизассемблер.

Потому, вся эта система команд не обкатывалась и не прогонялась ни в каком программном эмуляторе! Всё - в рамках симуляции LogiSim! А значит, это система команд реальной модели в симуляторе, вполне реализуемой 250 корпусами Советских ТТЛ.
И сам машинный код - уже читабельный листинг!
какой ляд мучит извилины безумными последовательностями байт ?Так пока царствует короныч, чем ещё мозги мучать? Сайтами зоны xxx или построением автомата открытой логикой?:v2_dizzy_vodka4:

Lethargeek

27.05.2020, 00:54

Так пока царствует короныч, чем ещё мозги мучать? Сайтами зоны xxx или построением автомата открытой логикой?
кароч, понял, что еще мне напоминает необходимость помнить контекст при кодинге - программирование эффективных вычислений на форте
и подозреваю, что 16-битная фортоподобная (двух)стековая машина получилась бы и производительнее, и проще такого 8-битного якобы-риска
в общем, для полного комплекта и чистоты эксперимента мозги надо мучить еще на тему "интуитивно-стекового ядра" ;)

TomaTLAB

27.05.2020, 01:24

"интуитивно-стекового ядра" Ну икфштагсл же? Не? :)

- - - Добавлено - - -

Так и Ктулху пробудить не долго :D

Lethargeek

27.05.2020, 01:35

Ну икфштагсл же? Не?
там нужна интуиция 80-го уровня :D
а попроще бы

Радио-86РК

27.05.2020, 09:02

кароч, понял, что еще мне напоминает необходимость помнить контекст при кодинге - программирование эффективных вычислений на форте
https://www.youtube.com/watch?v=5hhbGBlP3_4

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

Кое-где даёт сбой…
При манипуляции джойстиком симуляция может прерваться (глюк LogiSim?).
А при печати на клавиатуре может улететь в режим останова с перемигиванием лампочек для без нажатия на Забой…
Почему-то даже в ручном шаговом режиме часть шин уходит в неопределённость (я не про АЛУ). Думаю, LogiSim не тянет…

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

------------------------------------------------------------------------------
|Код команд / диапазоны|Группа |Описания, замечания, комментарий
-----------------------|----------|-------------------------------------------
00 |HLT |Прекращение счёта указателем команд IP
02-09 |REP 2-9 |Префикс повтора/пропуска операции n-раз
10-99 01 |ADD Ri,BCD|Двоично-десятичное накопление в регистр
0A-9F |ALU Ri,Tk |Операция АЛУ с комбинацией аргументов
A0-A9 B0-B9 C0-C9 D0-D9|REG Rn |Установка индекса активного регистра группы
AA-AD BA-BD CA-CD DA-DD|ARG Ri,Tj |Выбор комбинации аргументов операциям АЛУ
AE BE CE DE |EXT Ri |Экстракция данных из внешнего ОЗУ в регистр
AF BF CF DF |FIX Ri |Фиксация значения регистра во внешнее ОЗУ
E0-E7 |EX0-7 |Переход на адрес 0xE000-0xE700
E8-EF |Ecnd |Выполнение следующей команды по условию
F0 |FIN |Завершение с переходом на адрес Базы:Счёта
F1-FF |FN1-15 |Переход на адрес 0xF000-0xFF00
------------------------------------------------------------------------------
(n - устанавливаемый индекс, указанный битами команды)
(i или j - индекс, установленный раннее)
(k - индекс регистра временно берётся из старшего ниббла кода команды)

Группы регистров A0-A9, B0-B9 и C0-C9 составляют внутренний регистровый файл с
безусловным доступом к ним на программном уровне. Регистры B0-B9 хранят "Базу"
для обращения к памяти блоком в 256 байт, а регистры C0-C9 - счёт байта блока.
Инструкция с кодом F0 помещает текущий адрес указателя инструкций из IP в B0 и
C0, а значения из Bi и Cj помещает в IP, производя переход на адрес Bi:Cj. Тем
самым, можно обращаться к коду подпрограмм и знать адрес возврата через B0:C0.

Группу регистров D0-D9 составляют внешние Device-устройства с непосредственным
использованием в качестве операндов. Не рекомендуется активно использовать эту
группу в любых вычислительных действиях, так как нет гарантии работы программ.

Префикс REP используется для повтора любой операции на нужные n-тактов дольше.
Исключение представляет условная группа Ecnd, которая исполняет n-ую команду в
очереди, если условие ЛОЖНО.

************************************************** ****************************
* Примеры *
************************************************** ****************************

AA A1 1E |EOR A1,A1 ;Очистка по Исключающему Или (sf pf cf ZF)
AA A1 2E |EOR A1,A2 ;Исключающее Или A1 с A2 (?? ?? ?? ??)
AB A1 1A |EOR A1,B1 ;Исключающее Или A1 с B1 (?? ?? ?? ??)
AB A1 2A |EOR A1,B2 ;Исключающее Или A1 с B2 (?? ?? ?? ??)
AA A1 1E AB 2A |MOV A1,B2 ;Присвоение Исключающим Или (sf pf cf ZF)
AA A1 34 |SUM A1,34 ;Инкремент на константу (-- -- -- --)
AA A1 02 34 |SUM A1,2*34;Расширенный инкремент (-- -- -- --)
F8 |CALL 0xF800 ;Вызов подпрограммы
03 F8 |CALL 0xF803 ;Вызов подпрограммы с пропуском команд
F0 |RET ;Возврат из подпрограммы
03 F0 |RET 3 ;Возврат с переходом на команду #3
03 EC |EC 3 ;Условное выполнение по CF по команду #3
************************************************** ****************************
0000 03 EE A1 A2 A3 |IF ZF THEN {A1 A2 A3} ELSE A3
0005 03 EF A1 A2 A3 |IF ZF THEN A3 ELSE {A1 A2 A3}
000A 03 E0 A1 A2 A3 |GOSUB E003:A1:A2:A3
E003 03 F0 |RETURN TO A3
************************************************** ****************************

Радио-86РК

29.05.2020, 18:56

Чтoбы быть последовательным и честным, решил развернуть дешифратор команд из прошивки ПЗУ в элементарную комбинаторику.
Так в полной мере можно оценить простоту разработанной мною системы команд.
Правда, перевод BCD в Hex потребует двух сумматоров и одним встроенным в АЛУ сумматором не обойтись… Может, придётся удлинить цикл на ещё один такт… Это дело конкретной реализации…

К сожалению, не знаю, к какому классу архитектуры можно отнести всё это.
Для CISC - всё слишком примитивно.
Для RISC - не все команды просты своей логикой: Комбинация «03 F8» переходит на адрес F800 и пропускает 3 инструкции до адреса F803. Логически, это понятно и просто. Но реализация через счёт пропускаемых операций с режимом пропуска - уже сложно для понимания и выходит за рамки технологии RISC.
С другой стороны и к MISC отнести в полной мере не получается из-за отсутствия стека как такового…
(Операции PUSH/POP реализуются программным способом с "танцами под бубен"!)

Доработки
Немного подправил схему и логику…
Теперь комбинация «03 F8» переходит на адрес F830 по логике «Строка #3 дампа по адресу F800»…
Программировать стало легче, но программная реализация стека реализуется чудовищным кодом, так как её нельзя оформить в подпрограмму.
Почему так выходит: По плану, как уже писал выше, данный процессор задумывался основанием на ядро к x80-CISC в версии, где CISC-инструкция считывается и разворачивается в RISC-подпрограмму. Потому, получается, что поддержка внутреннего стека в рамках RISC не нужна, так как внешний стек через порты «D0…D9» будет реализовываться в CISC на внешнюю память…
Это плохо и не удобно для построения самостоятельной системы на данном процессоре и требует введения отдельных команд через резервные линии дешифратора…

Примерка кода
Если строить мой CISC x80 на базе данного ядра с прошивкой всех 32768 команд, то сам RISC-код будет всегда начинаться с адреса 0000 в ПЗУ с Гарвардским доступом. Если прикинуть и развернуть одну из операций, то получится примерно следующее:
x80: 54 |MOV AL,BL ; Команда x80
================================================== ======================
0000 DD D1 1E 02 88|MOV D1,0xB0 ; Регистр адреса ячейки контекста
0005 AA A1 1E AD 2D|MOV A1,D2 ; Считываем содержимое
000A DD 1E 02 80|MOV D1,0xA0 ; Регистр переключаем с BL на AL
000F DA D2 1D |OR D2,A1 ; Записываем данные
0012 00 |HLT ; Итого - 19 команд / 19 тактов
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Вместе с выборкой MOV AL,BL - 22 тактаУжасная производительность!!!

P.S.: Получается, строить внутренности x80 на данном процессоре слишком накладно и бесперспективно.
Работу над данной версией процессора в качестве ядра приостанавливаю, но не ставлю крест: Быть может, кому-нибудь пригодится как опытный образец…
Попробую посмотреть в сторону VLIW с длинной машинного кода под 32 бита.

hitomi2500

02.06.2020, 17:29

Я недавно собрал мелкое недо-WLIW ядрышко в ПЛИС на базе микрокода с целью эмулировать 8080. Ширина микрокода 18 бит ( в ПЛИС память такая), длина 1К (756 это код, а 256 - таблица вызовов и аргументов), объём ядра около 500 LUT4 и 200 триггеров. Не поддерживает пока прерывания, порты и HLT, все остальные инструкции работают. Несовместимо по таймингам и интерфейсу шины, всё-таки больше ориентировано на ПЛИС чем на дискретную логику. Проект с его участием далёк до завершения, так что оно пока сырое, но если есть желание посмотреть, могу поделиться.

Радио-86РК

03.06.2020, 04:11

Проект с его участием далёк до завершенияB OpenCores (https://opencores.org/) имеется?
если есть желание посмотреть, могу поделиться.Конечно есть!
всё-таки больше ориентировано на ПЛИС чем на дискретную логику.В пост-апокалипсис не добыть…

Кстати, устранил мелкие ошибки в схеме:
Операции «BE»/«CE» считывали данные из памяти преждевременно, из-за чего в регистры «Bn»/«Cn» попадали хаотические данные, так как многократно считывался байта адреса, на который и указывал сам регистр. Вентиль «2-И» всё исправил…
B0 C0 BE|MOV B0,B0:C0 ;Ячейка считывалась многократно и рандомно…
Наконец-то добавил самостоятельную «MOV» операцию прямо в АЛУ-группу:
; было…
A1 AA 1E|EOR A1,A1
AC 3D|OR A1,C3
; стало…
A1 AC 3F|MOV A1,C3Что мешало? Концепция! Думал сунуть команды битовых сдвигов в ту группу, но пришлось отдать её под «MOV», так как свистопляска достала…
Также и с префиксом «REP 2…9» не всё так гладко:
AC A1 07 2A|ADD A1,C2*7 ; Префиксом 07 (REP 7) сложение повторяется 7 раз
07 3B|SUB A1,C3*7 ; Вычитаение 7 раз
07 4C|AND (A1,C4) ; Чушь!!! Зачем маскировать 7 раз???
07 5D|OR (A1,C5) ; Чушь!!! Эти операции в повторе бессмысленны!
07 6E|EOR (A1,C6) ; Чушь!!! Чётное число повторов возвращают биты обратно!
07 7E|MOV (A1,C7) ; Чушь!!! Какой смысл в таком присваивании 7 раз?
B5 C5 07 AE|MOV A1,B5:C5; Чушь!!! Семь раз считывать из памяти???
07 AF|MOV B5:C5,A1; Чушь!!! Семь раз записывать в память???
07 A1|USE A1 ; Чушь!!! Семь раз выбирать индекс регистра???
07 AB|USE A1,B5 ; Чушь!!! Семь раз выбирать группу операндов???Думаю, под повтором нужно подключать иную логику. Например, внедрить операции «SHL»/«SHR» или «BIT»…
В общем, хоть таблица команд вроде бы и забита вся, но резервных комбинаций очень много получается под префиксом повтора!
Хоть механизмы пре-/пост-инкремента/декремента вводи, как в 68k… В этом случае коды 02…09 будут уже не префиксом «REP n», а каким-нибудь «MODE x»…
Сделать инкремент/декремент - лишь заменить регистры B₀…₉ и C₀…₉ на счётчики. За часик управиться можно, в перспективе…
Но, это точно выдавит процессор из класса RISC!

В файле «cnd_lib.ram» наконец-то появился код с командами «CALL»/«RET»/«JMP»/«Jcnd» с привязкой к стеку. Теперь можно вызвать подпрограммы вложением до сотни раз.
Операции «PUSH»/«POP» пока не описаны, но это достаточно легко реализуемо.

P.S.: В схему добавил два десятичных счётчика: Один считает такты до операции «00-HLT» в оперативном режиме, второй - фиксирует последний максимум…

hitomi2500

03.06.2020, 11:17

B OpenCores (https://opencores.org/) имеется?
Нет :) Конечный проект это упихать Радио-86РК в Tang Nano. Он абсолютно непрактичен, и в идеологию OpenCores не очень вписывается. Если взлетит (пока есть сомнения), то опубликую на гитхабе.

Конечно есть!
Пожалуйста : 72792
Там многое не очевидно, что-то возможно не соответствует описанию, документацию я не писал пока. Будут вопросы - обращайтесь.

В пост-апокалипсис не добыть…
В пост-апокалипсис мне кажется главные ценности это патроны и еда, а не электроника. А пока не наступил, купить указанную выше плату можно за $5.

Наконец-то добавил самостоятельную «MOV» операцию прямо в АЛУ-группу
Я наоборот её убрал, заменив сложением с регистром-нулём. Но у меня в опкоде три селектора для регистров.

Радио-86РК

03.06.2020, 23:45

Там многое не очевидно, что-то возможно не соответствует описанию, документацию я не писал пока. Будут вопросы - обращайтесь.Чтo-то я совсем запутался в исходниках! Видимо, не хватает опыта вникать в Verilog…
В пост-апокалипсис мне кажется главные ценности это патроны и еда, а не электроника.Смотря ещё, какой пост-апокалипсис. У отца ещё от цифровой АТС остались запчасти: Целый мешок с 155ЛА3, 155ТВ1 и пр…
Я наоборот её убрал, заменив сложением с регистром-нулём. Но у меня в опкоде три селектора для регистров.Просто концептуальные решения различаются: У меня всякая операндная лабуда задаётся одним байтом, чтобы не было никаких проклятущих битовых полей!
Левая тетрада и правая тетрада, как в известной песне (https://youtu.be/tBrApRTShAc) про калоши!

P.S.: Пока развивал схему в Logisim, понял, что левое полушарие мозга, отвечающее за логическое мышление, крайне плохо работает.
То есть, мне нравится Logisim за то, что в нём графически строится логическая схема. Причём, этот свой процессор я местами так и построил - методов "тыка": Делал один тик и смотрел, какой сигнал нужно подавить вентилем «И», какой сигнал необходимо подтянуть вентилем «ИЛИ», а где требуется разветвление мультиплексором сделать…
То есть, чисто визуально проработал всю логику процессора!
Вот, почему в Verilog'е у меня до сих пор всё туго - левое полушарие уже перегорело!:v2_dizzy_vodka4:

hitomi2500

04.06.2020, 08:04

Verilog/VHDL по сути почти не отличаются от Logisim. Только в Logisim всё рисуется графикой, а в Verilog описывается текстом. В ранних плисовых САПР было что-то очень похожее на Logisim (а в некоторых и до сих пор есть), но когда схемы стали усложняться, разбираться в графической паутине стало всё сложнее, даже с учётом иерархических блоков. Потому и придумали языки описания схем, в виде текста большая схема более читабельна. Так же как и с ЯВУ, в виде блок-схем в ядре Linux ни за что не разберёшься.
Если возникнет желание разбираться с верилогом, то по нему очень много и справочного и образовательного материала в интернете, на русском в том числе. А если нет, то в Vivado (и других плисовых сапрах тоже) можно сконвертировать верилог в схему, и рассматривать уже её. Могу попробовать наскриншотить. Правда схемы там обычно на много листов, и некоторые примитивы не имеют аналогов в дискретной логике.

Vslav

04.06.2020, 09:25

Нет :) Конечный проект это упихать Радио-86РК в Tang Nano.
Прошу прощения за небольшой оффтопик - а что там за среда разработки для Tang Nano? Руками уже пробовали?

hitomi2500

04.06.2020, 10:06

Радио-86РК

04.06.2020, 12:08

Если возникнет желание разбираться с верилогом, то по нему очень много и справочного и образовательного материала в интернете, на русском в том числе.
Вoт частичная модель моего процессора (http://www.edaplayground.com/x/2pm6)…
Но она такая кривая, что нужно переписывать с чистого листа!

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

Кстати, ниже архив - пародия на целевой процессор: Частичный дизассемблер…
В схеме - как бы всё красиво и последовательно. А в Verilog - тихий ужас!

andrews

04.06.2020, 19:34

Китайская среда от Gowin. Очень сильно похожа на Lattice Diamond. Лицензия бесплатная, но надо заказывать, можно через представителей в РФ. Где-то кажется был сайт с автоматической процедурой, но точно я не уверен. Для любителей опенсорса можно прикрутить Yosys, но PNR всё равно нужно использовать китайский, альтернативы пока нет.
Руками пробовал, RGB-полоски на дисплей выводил. Описанное выше ядро собрал, но без обвязки от него толку мало. Беда в том, что в плисе всего 4 блока по 18 килобит памяти, не разгуляешься. А внешняя - китайский QSPI PSRAM, я вообще такое впервые вижу. Видимо придётся делать кэш.
Если интересует Tang Nano как платформа, можно создать отдельную тему, чтобы здесь не оффтопить.

Получил на нашу компанию от наших соседей в Питере АО "Восток" поиграться. Только поскольку комп у меня дома 32 битный с ETHERNET, а там привязка к MAC лицензии, то "под Win32 Вы не сможете использовать OEM-овский синтезатор Synplify Pro
(он требует 64-разрядной ОС). У Вас будет возможность синтеза только в синтезаторе GowinSynthesis"
теперь нужно привезти какую-то плату посерьезней, на GW1N-2 хотя бы
Device: GW1N-1 GW1N-2 GW1N-4 GW1N-6 GW1N-9
LUT4: 1,152 2,304 4,608 6,912 8,640
Flip-Flop (FF) :864 1,728 3,456 5,184 6,480
Shadow SRAM S-SRAM(bits): 0 0 0 13,824 17,280
Block SRAM B-SRAM(bits): 72 K 180 K 180 K 468 K 468 K
B-SRAM quantity B-SRAM: 4 10 10 26 26
User Flash (bits): 96 K 256 K 256 K 608 K 608 K
18 x 18 Multiplier: 0 16 16 20 20
PLLs+DLLs: 1+0 2+2 2+2 2+4 2+4
Total number of I/O banks: 4 4 4 4 4
Max. user I/O: 119 207 207 273 273
Core Voltage (LV): 1.2 V 1.2 V 1.2 V 1.2 V 1.2 V
Core Voltage (UV) :– 2.5V/3.3V у всех кроме GW1N-1
Вопрос только на каких платах стоят не GW1N-1

Радио-86РК

04.06.2020, 21:37

Дo сих пор описываемый и разрабатываемый здесь процессор не имел никакого названия.
Если x80 (https://zx-pk.ru/threads/31789-x80-cisc-uzhe-ne-i8080-eshchjo-ne-i8086.html) формально задумывался как тот же x86, но 8-битный и с более нормальной (с моей точки зрения) таблицей команд. То в качестве возможного ядра для RISC-сердцевины CISC-оболочки x80 данный процессор получился безымянным как черновой вариант первой схемы в Logisim просто как прикол…

Однако, неделю назад всё-таки задумался о «кодовом названии», так как архитектура в целом получилась: уникальной: до сих пор не было процессора с машинным кодом «а поговорить?» самодостаточной: концептуально процессор очень гибок в самых неожиданных местах независимой: никакого copy-paste не было и любое схематическое решение я могу обосноватьТем самым, получилась совершенно самостоятельная ветка, которую можно развивать, усложняя систему команд (я про странные сочетания, типа «03 AE» или «03 C3»)…

И вот неделю назад, просмотрев один фильм 1982 года, решил вдруг этому фильму представить тёску…:v2_dizzy_indy:

P.S.: Судя по первой реакции социальных сетей, Verilog-проект всё же придётся разворачивать…:v2_dizzy_fire:

hitomi2500

04.06.2020, 23:53

Я сделал тему про Tang Nano и Gowin, всех интересующихся прошу туда:
https://zx-pk.ru/threads/31889-tang-nano-(plata-s-plis-za-5).html

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

Радио-86РК

10.06.2020, 18:31

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

Во-первых, у меня на выборку кода операции уходит 1 такт и 1 такт на исполнение. Это слишком мало и вероятна потеря стабильности на больших частотах. Если учитывать ещё такие трюки, когда код из памяти записывается в тот момент, когда сигнал чтения снимается, в надежде, что внутренние задержки меньше внешних и данные запомнятся прежде, чем внешняя схема успеет перейти в Z-состояние. Это - очень неправильно!
Во-вторых, так как у i8080, судя по его структурной схеме со внутренней шиной данных, вероятно используется много буферов с третьим состоянием, что позволяет сэкономить на мультиплексорах, то переход в Z-состояние и выход из него имеет физическую задержку и не позволяет поднять частоту выше скорости захвата/отпускания внутренней шины. Этот трюк я использовал у себя как наиболее экономичный, но он показал свою худшую сторону, так как на практике одновременная активация одного буфера с деактивацией других - штука крайне нестабильная и может выйти боком с конфликтами и перегревом элементов. Что требует вводить дополнительные такты для деактивации всех буферов с последующей активацией нужного…
В-третьих, если раннее я подсчитал порядка 250 микросхем, если исполнять схему как есть. То с применением мультиплексоров, оказывается, вместо буферов, поможет не только достичь большей производительности, но и, как это ни странно, сэкономить на элементах!

Итак, если взять регистровый файл с применением буферов, то получится примерно следующее: К155ИР13 - 30 штук
К531АП4 - 60 штук
К555ИД6 - 6 штук
ЛА/ЛЕ/ЛИ - 7-8 штукЕсли же использовать вариант с мультиплексорами, получается примерно так: К155ИР13 - 30 штук
К155КП1 - 24 штуки
К555ИД6 - 3 штукиТем самым, в текущем варианте на буферах получается порядка 100 корпусов, а в варианте с мультиксерами - всего около 60!
Выигрыш чуть ли ни в два раза!:v2_ohmy:
То есть, я здорово оплошал!
Вместо 250 корпусов может хватить уже меньше 200!!!

Разумеется, сейчас идёт работа над вариантом из мультиплексоров, так как в том же Logisim производительно так же повысится из-за снижения количества отдельным симулируемых элементов…

P.S.: Досадно, что изначально я просчитался и не занялся схемой на мультиплексорах.
Так как без интернета почти с неделю просидел без интернета из-за карантина с интернетом, работающим в долг, за прошлый месяц забыл оплатить и неделю просидел без сети. Здорово обленился и пришлось привыкать к мышке, клавиатуре и работе мозгами…
Из-за чего варианты под Proteus или Verilog вчера начал делать и бросил…
Надо Logisim-версию с мультиплексорами докончить. Но жутко лень…

hitomi2500

10.06.2020, 19:13

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

Радио-86РК

12.06.2020, 16:17

Кстати…Eсли я вернее понимаю, то я - вообще ничего не смыслю в архитектурах процессоров…:v2_dizzy_vodka4:
Вот, например, К531ИР24 (http://www.inp.nsk.su/~kozak/ttl/ttlh95.htm) годится для построения регистрового файла с внутренней шиной данных. Но, в моём случае, такие регистры бесполезны.

Есть какой-то К1533ИР39 (http://www.inp.nsk.su/~kozak/ttl/ttlh107.htm) (РОН), но подробного описания его применения найти не удаётся. Более того, аналога, почему-то, не существует и производство давно прекращено. А значит, быдло скоро весь их запас скупит и переработает в серёжки!:v2_dizzy_facepalm:
Хотя, если я правильно понял скуднейшее описание, как раз всю схему регистрового файла можно выполнить на шести ИР39, выбросив 30 микросхем регистров и 48 мультиплексоров! Пф-фф…:v2_dizzy_snowball2:
То есть, вся схема процессора сократилась бы до полусотни корпусов!:v2_huh:

За АЛУ симпатичнее подобие ИК2 (http://www.inp.nsk.su/~kozak/ttl/ttlh61.htm), чем запутанные и сложные ИК4 (http://www.inp.nsk.su/~kozak/ttl/ttlh62.htm) или ИП3 (http://www.inp.nsk.su/~kozak/ttl/ttlh70.htm)…
Преобразовывать BCD можно с ПР6 (http://www.inp.nsk.su/~kozak/ttl/ttlh126.htm).

Тем самым, по прикидкам, весь процессор мог бы получиться вполне простым в реализации дискретными микросхемами отечественного образца, но без ущерба концепции: Интуитивно-ясный машинный код…

P.S.: Сейчас перерисовываю схему, разбив всё на модули…
Однако, напрашивается ещё один модуль программного управления, так как FETCH получился слишком запутанным и я не могу сам разобраться в самой логике!
(Verilog отдыхает, так как делаю один полутакт и прокручиваю всю схему минутами, вникая в ситуацию и добавляя новые элементы! Уже говорил, что всю логику процессора построил правым полушарием мозга, а не левым: Не знаю, как в Verilog формулизировать её буду…)

hitomi2500

12.06.2020, 17:13

Verilog лишь описывает логику. Потом эту логику сборщик разложит на базовые кирпичики, а потом эту кучу кирпичей надо будет после оптимизации собрать в корпуса. А в качестве корпусов там всякие плисовые LUT6 и DSP48. Вот если бы можно было как-то заставить сборщик вместо плисовых примитивов использовать например серию К1533, да ещё и выбирать какие корпуса можно, а какие нельзя, тогда можно было бы схему любой сложности из текста на verilog-е собрать, причём в минимальном числе корпусов. Я к сожалению мало знаю о том, как устроены все эти сборщики изнутри, но могу поспрашивать у опенсорсников насколько это вообще реально.

Радио-86РК

14.06.2020, 19:01

Verilog лишь описывает логику.Этo и видно по выхлопу с Icarus Verilog, где можно, при желании, самому переварить файл и организовать симуляцию.

Вчера переносил схему декодера команд с Logisim на Proteus и жутко устал: Logisim: Чтобы удалить провод, достаточно его прорисовать повторно - принцип XOR
Proteus: Удаление провода - целая история с правыми кликами или клавишами клавиатуры
Logisim: Чтобы заменить один элемент другим, достаточно удалить и поставить новый
Proteus: Удаление элемента удаляет также и все проводники, подключённые к нему. А автоматическая замена элементов ведёт себя не так, как ожидается
Logisim: Перенос провода переносит и точки соединения тоже
Proteus: Провод перемещаешь, а узлы пайки остаются на месте и нужно много шаманить кликами
Logisim: В любой момент состояние триггера, регистра или счётчика можно изменять как хочешь
Proteus: Любое изменение в схеме требует прервать симуляцию и элементы памяти сбрасываются, а изменить статус триггера или счётчика никак нельзяВ общем, в Logisim схему легче прорабатывать в режиме «как попало» и не прерывая симуляции можно добавлять элементы и провода. Тогда как Proteus - для профессионалов, чётко знающих свой план.
(Как Бейсик против Паскаля!)

Схему нарисовал и запустил - получил ругань на элемент 7485: Оказывается, имеется графическая модель, но отсутствует симуляторная.
Пришлось выискивать среди 74LS86 и минут десять заменять с пляской над проводами (автозамена странно выполняется).
А после прокрутки счётчика оказалось, что я ошибочно влепил 7433 вместо 7402: Снова плясал с заменой и изуродовал схему из-за длинных выводов в графике 7402…
(Про графическое редактирование знаю, но возиться лень было…)

В Logisim схема декодера команд выглядит компактнее и красивее, чем та же в Proteus…
(Нужно будет попыхтеть над УГО…)

P.S.: По-любому, прорабатывать схему процессора прямо в Proteus лично я не смогу…
Буду тупо переносить с Logisim готовые узлы…
P.P.S.: Перерисовал Logisim-схему. Активный выходной уровень - низкий, что уже гарантирует некоторую устойчивой к помехам. Чтобы ввести разрешающий вход EN, пришлось здорово повозиться с запретом элементов. Сложность была в том, что схема не имеет одного главного вентиля и запрещать требовалось множество элементов. К тому же, ещё не выходить за рамки: 4-И-НЕ уже не годится из-за расхода корпусов. Оптимизировал комбинаторику и схема, приобретя реакцию на EN, сократилась на один корпус, что приятно удивило!
Затем перерисовал своими УГО Proteus-схему заново и справа-налево: От выходных 3-И-НЕ элементов до ключевой комбинаторики, чтобы как можно больше корпусов подключались короткими дорожками без петель и переходов.
В итоге, судя по топологии генерируемой разводки платы 50×70 переходных отверстий не так много и большинство дорожек - прямые…
Очень сильно устал…

Радио-86РК

12.01.2021, 05:43

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

Сейчас прорабатываю новый вариант многотактового процессора с кучей машинных циклов.
Регистровый Файл из отдельного запутанного модуля двухпортовой памяти перенёс прямо в ОЗУ, следуя традициям MOS 6502…
Тем самым, на исполнение одной команды может потребоваться от 1 до 11 тактов, так как Счётчик Машинных Циклов строго управляет всем архитектурным состоянием на весь период исполнения команды.
Фаза M0: Чтение PSW
Фаза M1: Чтение Аккумулятора
Фаза М2: Чтение регистра второго операнда
Фаза M3: Чтение регистра-Счётчика
Фаза M4: Чтение указателя Базы буфера
Фаза M5: Чтение ячейки ОЗУ
Фаза M6: Запись Аккумулятора
Фаза M7: Запись Счётчика
Фаза M8: Запись Базы
Фаза M9: Запись PSW или данных в ОЗУ
74435
Как видно, в отличии от i8080/z80 с наличием Цикла M1, здесь циклы могут начинаться с M0, однако он не привязан к чтению кода команды из памяти, так как все 10 циклов M0…M9 управляют именно исполнением текущей инструкции, а не её выборкой.
Так, команда «ADD A1,[B5C5+D7+9]» развернётся в следующую последовательность циклов:
M0: Чтение PSW - ячейка [0xA0]
M1: Чтение D7 - ячейка [0xD7]
M2: Чтение A1 - ячейка [0xA1]
M3: Чтение C5 - ячейка [0xC5]
M4: Чтение B5 - ячейка [0xB5]
M5: Чтение ОЗУ - ячейка [B5C5+D7+9]
M6: Запись A1 - ячейка [0xA1]
M9: Запись PSW - ячейка [0xA0]
Здесь видно, что на всю операцию затрачивается 8 тактов + ещё два: Выборка константы «9» и выборка команды «ADD», что происходит вне этих циклов.
(Здесь «M9» управляет записью либо PSW, либо произвольной ячейки ОЗУ, так как не предусматриваются команды АЛУ над ячейками памяти в открытой форме.)

P.S.: До сих пор имелись значительные сложности без наличия Счётчика Циклов.
Тогда как теперь всё можно достаточно слаженно расписать по тактам…

Радио-86РК

20.02.2021, 02:42

Зa весь этот период много всего переделано по теме.
А именно:
Нарисовал много разных схем в Logisim
Написал несколько вариантов на Verilog
Прогнал всё в среде Quartus/ModelSim
Написал эмулятор…
Собственно, представляю вашему вниманию эмулятор данного в теме процессора для РАДИО-86РК.
В архиве 74764 имеется два файла, где «emulator.rkr» собственно само ядро эмуляции размером в 272 байта, загружаемое в область 0x5B00…0x5C0F, чтобы можно было и на ZX-Spectrum'е запустить, предварительно заменив все jp'ы на jr'ы для компактности. Ядро полностью выполняет весь байт-код.
Также в архиве имеется второй файл «emulater.rkr», который представляет собой микросреду для эмуляции.

Напомню, что суть процессора в том, что как байт-код кодируется, то он и обозначает. Своего рода WYSIWYG-машинный код.
Как и виртуальная Java-машина, здесь байт-код тоже выполняется виртуально процессором i8080/z80. А также, напомню, выполняется на уровне Verilog, что позволяет на уровне ПЛИС/FPGA реализовать самый настоящий процессор.
Или же перепрошить ПЗУ АОНа на z80 для эмуляции данного процессора.

Так, байты A0…A9/B0…B9/C0…C9/D0…D9 активируют одноимённые РОН. Как можно догадаться, всего РОН 40. Причём, A0 - это PSW, а D0…D9 - внешние УВВ.
Байты AA…AD/BA…BD/CA…CD/DA…DD группируют регистры в операнды для АЛУ.
Например, код «A2 AB 3E» воспринимается как «A2 A,B3 Eor» и работает как «EOR A2,B3».
Тем самым, никакую таблицу команд заучивать и зубрить не надо. Только чуточку нужно приобрести навык и можно спокойно кодировать алгоритм.

Так как D0…D9 выполняют функцию УВВ, временно в «emulater.rkr» создана такая среда:
D0: Чтение - код символа под курсором / Запись - печать ASCII-символа
D1: Чтение - проверка клавиатуры / Запись - печать HEX-байта
D2: Чтение - ожидание ввода с клавиатуры / Запись - BEEP-тональность
D3: Чтение - опрос клавиатуры без ожидания / Запись - BEEP-длительность
D4: Чтение - Позиция курсора по X
D5: Чтение - Позиция курсора по Y
D9 - Должен работать как переключатель страниц УВВ. То есть, если 0x00 - функционал выше, то 0x57 - функционал i8257 с управлением через D0…D8. А 0x53 - функционал i8253. Проще говоря, здесь хранится код выбранного УВВ
То есть, «PRINT CHR$(USR(-2045))» это «LET D0 = D2», которое мнемонически представляется как «MOV D0,D2» и кодируется кодом «D0 DD 2F».
Verilog-модель выполняет эту команду примерно за 33 такта.

Примеры:
0100 A1 |REG A1 ; Выбор A1 в качестве аккумулятора
0101 AB |ARG A,B ; Операнд-аккумулятор A и операнд-источник B
0102 2D|OR A1,B2 ; Здесь «2» определяет индекс операнда-источника, а «D» означает «Disjunct»
0103 3D|OR A1,B3 ; Здесь «3» определяет индекс операнда-источника
0104 65 4D|OR A1,[BC6+5+B4] ; Префикс «65» выбирает регистровую пару B6 и C6 как указатель памяти со смещением
0106 A7 |REG A7 ; Меняем аккумулятор на A7
0107 65 4D|OR A7,[BC6+5+B4] ; Та же операция, но результат помещается в A7
0109 AC |ARG A,C ; Операнд-аккумулятор A и операнд-источник C
010A 65 4D|OR A7,[BC6+5+C4] ; Такая же операция, но смещение берётся из C4
010C 5E|EOR A7,C5 ; Инструкция XOR
010D 5F|FOR A7,C5 ; Инструкция MOV
010E 5A|ADD A7,C5 ; Сложение
010F 5B|SUB A7,C5 ; Вычитание
0110 65 D6|MOV [BC6+5],D6 ; Запись из регистра УВВ в память
0112 65 CF|JCF [BC6+5] ; Если !CF, то прыжок на адрес из пары B6 и C6 со смещением 5
0114 65 43|JMP 0x4365 ; Два префикса в подряд - переход (в B0 и C0 сохранится адрес 0x0115)
0116 F1|JMP 0xF100 ; Переход на начало Функции #1 (в B0 и C0 сохранится адрес 0x0116)
0117 23 F1|JMP 0xF123 ; Переход внутрь Функции #1 (в B0 и C0 сохранится адрес 0x0118)
0119 21 00|JMP 0x0021 ; Переход в начальный параграф памяти (в B0 и C0 сохранится адрес 0x011A)
011B 00|HLT ; Останов: Переход на 0000, как RST 0 (в B0 и C0 сохранится адрес 0x011B)Как можно видеть, ничего сверхъестественного нет. Именно поэтому подобную систему команд можно легко выполнять и эмулятором, и в Verilog, и в Logisim, что близко по уровню к ТТЛ.

А главное - никакого BrainF*ck'а! Никакой эзотерики!
Машинный код прост и очевиден, если есть хоть малое желание вникнуть!

А так как запустить Java-игру на i8080 почти нереально, то с данным кодом можно, напротив, и в ТТЛ баловаться, и на РАДИО-86РК, и в браузере JavaScript-эмулятором.
Короче, кроссплатформенность обеспечивается.

P.S.: Как понятно, переключатель УВВ через D9 мною не реализован в файле «emulater.rkr», так как на данном этапе это не требуется.

Радио-86РК

26.02.2021, 22:11

Эмулятор
Написал и более-менее отладил эмулятор (74808): 3700…37C6: Оболочка («РАДИО-86РК¹» / «СПЕЦИАЛИСТ²» / «ОРИОН-128³»)
3838…3863: Сам псевдо-код для эмулятора
3870…38FF: Поддержка совместимости между разными ПК (¹-²-³ и ZX-Spectrum 48Kb) для печати символа и ввода с клавиатуры
3900…3A99: Собственно, код самой эмуляции (поддерживаются практически все инструкции)
3ADA…3C7F: Дизассемблер (декодирует практически все команды)
3C80…3CFF: Заглушка портов УВВ (вывод сообщений о попытках доступа к портам)
Оболочка в первую очередь разрабатывалась под РАДИО-86РК, где и отлаживалось всё.
Адрес эмулятора 3870…3CFF выбран не случайно, так как ZX-Spectrum 48 Kb в ROM#2 по этим адресам имеются FF.
То есть, всё разрабатывалось, чтобы код прошить прямо в ПЗУ и не требовалось что-либо грузить с ленты.:v2_dizzy_sleep2:

Итого
Таким образом, свою идею персонального процессора я реализовал: Рабочим эскизом в Logisim
Эмулятором на JavaScript
Моделью на Verilog с перспективой реализации в ПЛИС/FPGA
Эмулятором под процессор i8080/z80
В ходе разработки данного эмулятора решил некоторые концептуальные проблемы и белые пятна архитектуры: Теперь нужно доработать эскизы Logisim/Verilog.
Инструкция ARG D,D теперь запрещена и работает как DBG. Тем самым, из-за её упразднения уже никак нельзя выполнить инструкцию, типа «MOV D1,D2» (непосредственная пересылка из порта #2 в порт #1), так как появилась инструкция DBG
Инструкции JNS/JPO/JNC/JNZ упразднены и на их месте теперь CMS/CMO/CMC/CMZ - инверсия соответствующих флажков. Теперь «JNC» - это «CMC+JC»
Наконец-то в адресации появился авто инкремент/декремент для организации стека: Так как в качестве индексного регистра неразумно указывать регистр порта УВВ, теперь в рамках индексной адресации они и работают в качестве счётчиков (считает только D₉, остальные D₀…₈ лишь определяют направление счёта и смещение)
Некоторые комбинации так и не определены. Условно они обозначаются как инструкции EXA/EXB/EXC/EXD/EXE

Теперь предстоит данный код эмулятора/дизассемблера вписать в ZX-ROM и аккуратненько прогнать в EmuZWin…:v2_dizzy_snowball2:

Error404

28.02.2021, 18:31

Чем описанное виртуализирующее ядро будет лучше например ZPU (https://zx-pk.ru/threads/32514-zpu-na-vektore.html) ?
Чем ZPU лучше на мой взгляд, это тем что там изначально несколько другая цель - подружить при его помощи самые разные целевые 8-битные платформы с современными популярными средствами разработки, что позволяет делать простым портирование сложного софта (в т.ч. и софта изначально написанного под куда большие разрядности и более мощную математику, чем принято у 8-биток). В 2021 изучать новый машкод чтобы потом на нем творить что-то сложное (а иначе зачем?) ИМХО путь тупиковый в силу слишком высокого образовательного порога и низкого полезного выхлопа у программиста (а именно наличие софта решает в любом программно-аппаратном комплексе).

Радио-86РК

01.03.2021, 06:50

Чем описанное виртуализирующее ядро будет лучше например ZPU ?Нe знаю. Сейчас все помешаны на стековых машинах.

В 2021 изучать новый машкод чтобы потом на нем творить что-то сложное (а иначе зачем?)Машкода как такового нет. Что в дампе видится, то и значится.
ИМХО путь тупиковый в силу слишком высокого образовательного порога и низкого полезного выхлопа у программистаГде-то читал заметку/байку, что современные инженеры/программисты выпускники не знают что такое байт-код и маш-код.:v2_confu:

У меня - никакой таблицы системы команд практически нет. Что в дампе видишь, то и значит:
Видишь «A1» - значит активируется регистр «A1»
Видишь «AB» - значит скоро в АЛУ поступят операнды регистров «A,B»
Видишь «3D» - значит регистр #3 участвует в Дизъюнкции - «OR A1,B3»
Видишь «00» - значит «конец строки» - HLT
Вот так байт за байтом простыми командами «A1 AB 3D» собирается целая команда «OR A1,B3».

Хочется Форт синтаксиса?
Тогда «A1 AB 3D» - это «A1 B3 Disj».

Никаких битовых полей, никакой эзотерики.

Префиксы - BCD-числа от 1 до 99.
3456 A1 |REG A1
3457 AB |ARG A,B
3458 3D|OR A,B3
3459 65 4D|OR A,[B4][BC6][5]
345B 87 DD|DAD BC8,BC7
345D CF|CMC
345E 87 CE|JC [BC8][7]
3460 65 AB|XCHG A6,B5
3470 43 C2|MOV [BC4][3],C2
3472 18 F8|CALL 0xF818
3474 F8|CALL 0xF800
3475 18 00|CALL 0x0018
3477 00|CALL 0x0000 (HLT)Коды E0…FF так и работают однобайтовыми «CALL 0xE000…0xFF00» и программно можно наращивать функционал виртуальными инструкциями.

P.S.: Согласен, архитектура - для любителя копаться в дампах.
Но у LMC (http://educomp.runnet.ru/lmc/lmc_op_codes.html) эзотерики в сухих цифрах больше.
А общее - одно: 00 - HLT

Радио-86РК

16.06.2021, 15:00

Написaл Эмулятор (https://gistpreview.github.io/?67df94e98ab48c8f3117bb5266b3496e) (поддерживает Автозапуск (https://gistpreview.github.io/?67df94e98ab48c8f3117bb5266b3496e#autorun)).

Данная HTML5-версия эмулятора дизайном выполнена в стиле Windows'95.
Кнопка «RUN» запускает цикл эмуляции до инструкции останова «HALT».
Кнопка «STEP» предназначена для пошаговой отладки программного кода.

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

Внизу отображается графический дисплей из двух слоёв.
Верхний слой - монохромная графика 128×128, которая строится непосредственно программным способом.
Нижний слой - произвольное цветное изображение импровизированных ЖК-сегментов, представляющих собой готовые спрайты, которые неподвижны и программа может их только включать и выключать. В качестве демонстрационного ЖК-экрана была выбрана сцена из карманной игры Автослалом (https://ru.wikipedia.org/wiki/%D0%AD%D0%BB%D0%B5%D0%BA%D1%82%D1%80%D0%BE%D0%BD%D 0%B8%D0%BA%D0%B0_%D0%98%D0%9C-23).

Карта Портов Устройств Ввода-Вывода
Данная система своим концептуальным дизайном планировалась максимально открытой.
Как писалось выше с самого начала, система команд кодируется сквозным образом, где две тетрады байта команды представляют собой аббревиатуру команды.
Таким образом, никакой особой карты УВВ не разрабатывалось, так как в качестве портовых служат регистры D₀…₉, где D₉ служит селектором микросхемы УВВ, а через D₀…₈ осуществляется уже непосредственный доступ к микросхеме УВВ:
╔════╤════════╤═� �════════════════� ��════════════════ ════════════════� �════════════╗
║ D9 │ ИМС │ Описание доступа к ресурсам микросхемы через РОН процессора ║
╠════╪════════╪═� �════════════════� ��════════════════ ════════════════� �════════════╣
║0x53│ i8253 │ D0/D1/D2 - Каналы Счётчиков 0/1/2 ║
║ │К580ВИ53│ D3 - Регистр Статуса Таймера ║
╟────┼────────┼─� �────────────────� ��──────────────── ────────────────� �────────────╢
║0x55│ i8255 │ D0/D1/D2 - Порты A/B/C ППА ║
║ │К580ВИ55│ D3 - Регистр Статуса ППА ║
╟────┼────────┼─� �────────────────� ��──────────────── ────────────────� �────────────╢
║0x57│ i8257 │ D0/D2/D4/D6 - Каналы 0/1/2/3: ПДП Адрес ║
║ │ │ D1/D3/D5/D7 - Каналы 0/1/2/3: ПДП Счёт ║
║ │К580ВТ57│ D8 - Регистр Статуса ПДП ║
╟────┼────────┼─� �────────────────� ��──────────────── ────────────────� �────────────╢
║0x75│ i8275 │ D0 - Регистр Данных ║
║ │К580ВГ75│ D1 - Регистр Статуса ║
╟────┼────────┼─� �────────────────� ��──────────────── ────────────────� �────────────╢
║0x79│ i8279 │ D0 - Регистр Данных ║
║ │К580ВВ79│ D1 - Регистр Статуса ║
╟────┼────────┼─� �────────────────� ��──────────────── ────────────────� �────────────╢
║0x93│ FD1793 │ D0 - Регистр Команд / Регистр Статуса ║
║ │ │ D1 - Регистр Дорожки ║
║ │ │ D2 - Регистр Сектора ║
║ │1818ВГ93│ D3 - Регистр Данных ║
╚════╧════════╧═� �════════════════� ��════════════════ ════════════════� �════════════╝Как видите, для работы с ИМС i8257/К580ВТ57 достаточно в D₉ поместить номенклатурный индекс целевой ИМС BCD-кодом, а затем через регистры D₀…₈ уже программировать режим её работы.

Демонстрационный Код
На данный момент имеется начальная реализация эмуляции ИМС i8279/К580ВВ79 для считывания кода клавиши из соответствующего текстового поля.
Для управления пикселями монохромного слоя служит виртуальное LCD-УВВ с кодом 0xCD в D₉, где в D₈ записывается целевая X:Y позиция знакоместа на экране, а D₀…₇ имитируют ч/б матричный принтер и управляют пикселями в вертикальной компоновке байтов на экране.
Для управления спрайтовыми ЖК-сегментами служит виртуальное цветное УВВ с кодом 0xCB в D₉, где через D₀…₇ маскируются целые спрайты на самом экране и воспроизводится сцена игры «АвтоСлалом» в слегка зашумленном виде, так как имеется вариант имитации ЖК-экрана с помощью отображения кадра непосредственно из ПЗУ, куда прошивается сцена и отображается на бытовой ТВ.
(Не всякое изображение подходит, так как был разработан специальный редактор для ручного индексирования всех элементов сцены в отдельный спрайт ЖК-сегмента, из-за чего на итоговом экране можно заметить артефакты небрежной работы мышкой.)

ТВ-имитатор сегментного ЖК
Можно взять любую графическую систему отображения (хоть от ZX-Spectrum) и пропустить все пиксели из ПЗУ через такой каскад:75614Но это - другая история разработки…
Но на странице эмуляции рендер работает по принципу со схемы и можно изучить алгоритм упаковки изображения.

Итог
Таким образом, удалось более-менее разобраться с проблемой трансляции кода и его исполнения.
А благодаря браузерному исполнению эмулятора можно ознакомиться с представляемой здесь архитектурой на любом интерактивном устройстве.