Проектирование процессора

[Alikberov]

Как обладатель РЛК "Электроника КР-03", после освоения принципов программирования вообще и изучения схемы, как-то быстро вдруг родилось желание:

Разработать компьютер на своей архитектуре
Использовать процессор собственной архитектуры

Что превратилось в хобби на всю последующую жизнь.

Изучив много справочников по процессорным системам многих отечественных серий, к концу 90-х появились первые наброски эмуляторов собственных моделей процессоров. Однако, везде всплывали проблемы разного рода. То загрузка данных в регистры не была проработана, то ветвления не продуманы.
И все 20 лет просто не приносили никакого результата, хотя я и написал несколько рабочих эмуляторов РАДИО-86РК и эмулятор процессора i8086.
Из опытов с i8086 с его странным машинным кодом 00 как команда ADD, а не NOP, был выработан основной постулат, что:

Как и с текстом, код 00 должен означать "терминацию" цепочки - HLT (Останов)


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

Коды A0..A9 воспринимаются как "один из десяти Аккумуляторов" - пусть они будут командами активации одного из Аккумуляторов
Коды B0..B9 воспринимаются как "одна из десяти Баз/Буферов" - пусть они будут командами активации одного из Буфера
Коды C0..C9 воспринимаются как "один из десяти Счётчиков" - пусть они будут командами активации одного из Счётчиков
Коды D0..D9 воспринимаются как "один из десяти Девайсов" - пусть они будут командами активации одного из Устройств Ввода-Вывода

Получается всего 30 Регистров Общего Назначения + 10 УВВ.

Для нормального функционирования АЛУ-операций требуется, как минимум, пара операндов. Здесь очень кстати подходят коды:
AA/AB/AC/AD - как операнды (A,A) / (A,B) / (A,C) и (A,D)
BA/BB/BC/BD - как операнды (B,A) / (B,B) / (B,C) и (B,D)
CA/CB/CC/CD - как операнды (C,A) / (C,B) / (C,C) и (C,D)
DA/DB/DC/DD - как операнды (D,A) / (D,B) / (D,C) и (D,D)

И здесь остаётся лишь найти группу кодов под АЛУ-Операции. В самой АЛУ-операции необходимо выбирать индекс правого операнда, так как левый - выбирается до АЛУ-операции как приёмник результата:
0A..9A - операция Add, где цифра - индекс правого операнда
0B..9B - операция suB, где цифра - индекс правого операнда
0C..9C - операция and(Conjunct), где цифра - индекс правого операнда
0D..9D - операция or(Disjunct), где цифра - индекс правого операнда
0E..9E - операция Eor(Xor), где цифра - индекс правого операнда
0F..9F - пересылка mov(For), где цифра - индекс правого операнда

Тем самым:
код "CB C1 2A" означает "ADD C1,B2"
код "BA B2 3E" означает "EOR B2,A3"

Легко вникнуть, легко освоиться, легко кодировать!

Вот полная таблица:

+------+------+------+------+------+------+------+------+------+------+------+------+------+------+------+------+
| .0 | .1 | .2 | .3 | .4 | .5 | .6 | .7 | .8 | .9 | .A | .B | .C | .D | .E | .F |
+----+------+------+------+------+------+------+------+------+------+------+------+------+------+------+------+------+
| 0. | HLT | | | | | | | | | | ADD | SUB | AND | OR | EOR | MOV |
| | | D0+1 | D0+2 | D0+3 | D0+4 | D0+5 | D0+6 | D0+7 | D0+8 | D0+9 | R,T0 | R,T0 | R,T0 | R,T0 | R,T0 | R,T0 |
+----+------+------+------+------+------+------+------+------+------+------+------+------+------+------+------+------+
| 1. | | | | | | | | | | | ADD | SUB | AND | OR | EOR | MOV |
| | D1+0 | D1+1 | D1+2 | D1+3 | D1+4 | D1+5 | D1+6 | D1+7 | D1+8 | D1+9 | R,T1 | R,T1 | R,T1 | R,T1 | R,T1 | R,T1 |
+----+------+------+------+------+------+------+------+------+------+------+------+------+------+------+------+------+
| 2. | | | | | | | | | | | ADD | SUB | AND | OR | EOR | MOV |
| | D2+0 | D2+1 | D2+2 | D2+3 | D2+4 | D2+5 | D2+6 | D2+7 | D2+8 | D2+9 | R,T2 | R,T2 | R,T2 | R,T2 | R,T2 | R,T2 |
+----+------+------+------+------+------+------+------+------+------+------+------+------+------+------+------+------+
| 3. | | | | | | | | | | | ADD | SUB | AND | OR | EOR | MOV |
| | D3+0 | D3+1 | D3+2 | D3+3 | D3+4 | D3+5 | D3+6 | D3+7 | D3+8 | D3+9 | R,T3 | R,T3 | R,T3 | R,T3 | R,T3 | R,T3 |
+----+------+------+------+------+------+------+------+------+------+------+------+------+------+------+------+------+
| 4. | | | | | | | | | | | ADD | SUB | AND | OR | EOR | MOV |
| | D4+0 | D4+1 | D4+2 | D4+3 | D4+4 | D4+5 | D4+6 | D4+7 | D4+8 | D4+9 | R,T4 | R,T4 | R,T4 | R,T4 | R,T4 | R,T4 |
+----+------+------+------+------+------+------+------+------+------+------+------+------+------+------+------+------+
| 5. | | | | | | | | | | | ADD | SUB | AND | OR | EOR | MOV |
| | D5+0 | D5+1 | D5+2 | D5+3 | D5+4 | D5+5 | D5+6 | D5+7 | D5+8 | D5+9 | R,T5 | R,T5 | R,T5 | R,T5 | R,T5 | R,T5 |
+----+------+------+------+------+------+------+------+------+------+------+------+------+------+------+------+------+
| 6. | | | | | | | | | | | ADD | SUB | AND | OR | EOR | MOV |
| | D6+0 | D6+1 | D6+2 | D6+3 | D6+4 | D6+5 | D6+6 | D6+7 | D6+8 | D6+9 | R,T6 | R,T6 | R,T6 | R,T6 | R,T6 | R,T6 |
+----+------+------+------+------+------+------+------+------+------+------+------+------+------+------+------+------+
| 7. | | | | | | | | | | | ADD | SUB | AND | OR | EOR | MOV |
| | D7+0 | D7+1 | D7+2 | D7+3 | D7+4 | D7+5 | D7+6 | D7+7 | D7+8 | D7+9 | R,T7 | R,T7 | R,T7 | R,T7 | R,T7 | R,T7 |
+----+------+------+------+------+------+------+------+------+------+------+------+------+------+------+------+------+
| 8. | | | | | | | | | | | ADD | SUB | AND | OR | EOR | MOV |
| | D8+0 | D8+1 | D8+2 | D8+3 | D8+4 | D8+5 | D8+6 | D8+7 | D8+8 | D8+9 | R,T8 | R,T8 | R,T8 | R,T8 | R,T8 | R,T8 |
+----+------+------+------+------+------+------+------+------+------+------+------+------+------+------+------+------+
| 9. | | | | | | | | | | | ADD | SUB | AND | OR | EOR | MOV |
| | D9+0 | D9+1 | D9+2 | D9+3 | D9+4 | D9+5 | D9+6 | D9+7 | D9+8 | D9+9 | R,T9 | R,T9 | R,T9 | R,T9 | R,T9 | R,T9 |
+----+------+------+------+------+------+------+------+------+------+------+------+------+------+------+------+------+
| A. | REG | REG | REG | REG | REG | REG | REG | REG | REG | REG | ARG | ARG | ARG | ARG | CLR | NOT |
| | A0 | A1 | A2 | A3 | A4 | A5 | A6 | A7 | A8 | A9 | A,A | A,B | A,C | A,D | AF | AF |
+----+------+------+------+------+------+------+------+------+------+------+------+------+------+------+------+------+
| B. | REG | REG | REG | REG | REG | REG | REG | REG | REG | REG | ARG | ARG | ARG | ARG | CLR | NOT |
| | B0 | B1 | B2 | B3 | B4 | B5 | B6 | B7 | B8 | B9 | B,A | B,B | B,C | B,D | BF | BF |
+----+------+------+------+------+------+------+------+------+------+------+------+------+------+------+------+------+
| C. | REG | REG | REG | REG | REG | REG | REG | REG | REG | REG | ARG | ARG | ARG | ARG | CLR | NOT |
| | C0 | C1 | C2 | C3 | C4 | C5 | C6 | C7 | C8 | C9 | C,A | C,B | C,C | C,D | CF | CF |
+----+------+------+------+------+------+------+------+------+------+------+------+------+------+------+------+------+
| D. | REG | REG | REG | REG | REG | REG | REG | REG | REG | REG | ARG | ARG | ARG | ARG | CLR | NOT |
| | D0 | D1 | D2 | D3 | D4 | D5 | D6 | D7 | D8 | D9 | D,A | D,B | C,D | D,D | DF | DF |
+----+------+------+------+------+------+------+------+------+------+------+------+------+------+------+------+------+
| E. | INT | INT | INT | INT | INT | INT | INT | INT | INT | INT | INT | INT | INT | INT | INT | INT |
| | E000 | E100 | E200 | E300 | E400 | E500 | E600 | E700 | E800 | E900 | EA00 | EB00 | EC00 | ED00 | EE00 | EF00 |
+----+------+------+------+------+------+------+------+------+------+------+------+------+------+------+------+------+
| F. | INT | INT | INT | INT | INT | INT | INT | INT | INT | INT | INT | INT | INT | INT | INT | INT |
| | F000 | F100 | F200 | F300 | F400 | F500 | F600 | F700 | F800 | F900 | FA00 | FB00 | FC00 | FD00 | FE00 | FF00 |
+----+------+------+------+------+------+------+------+------+------+------+------+------+------+------+------+------+
Где:
коды E0..FF работают как программное прерывание на адреса E000..FF00, при этом в регистрах B0 и C0 сохраняется "адрес возврата"
код CF буквально инвертирует "Флаг CF"
Регистр A0 выполняет функцию PSW для хранения флагов:

AF - Арифметический Флаг (аналог SF)
BF - Буферный Флаг (Арифметическое переполнение, аналог OF)
CF - Флаг Переноса
DF - Дифференциальный Флаг (аналог ZF, только наоборот - NZ)

Практически, это - весь набор команд.
Чтобы начать программировать, даже в таблицу заглядывать не стоит: Всё "на своих местах" в буквальном смысле.
Причём, коды BCD с 01 по 99 работают как префиксы адресации ячейки памяти, где D0-D9 - "Двойной регистр" / "Регистровая пара" B0:C0..B9:C9.


код "CB C1 2A" означал "ADD C1,B2", а с префиксом "CB C1 54_2A" означает "ADD C1,[D5+4],B2"
код "BA B2 3E" означал "EOR B2,A3", а с префиксом "BA B2 54_3E" означает "EOR B2,[D5+4],A3"
код "CF" означал "NOT CF" (CMC), а с префиксом "54 CF" означает "JCF [D5+4]"
код "C1" означал активацию регистра C1 как приёмника результата для АЛУ, а с префиксом "54_C1" означает "MOV [D5+4],C1"

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

Для фанатов программирования машинного кода освоить кодирование под такой процессор будет как никогда легко!

Вот схема рабочего прототипа 2019 года:
79047
А вот аккуратный эскиз процессора (отсутствуют блок регистрового файла и блок АЛУ).
79048

JavaScript-эмулятор доступен здесь (https://gistpreview.github.io/?cff9df3bc1901d33f5c055682721240a#autorun).
Эмулятор моего процессора под РАДИО-86РК - здесь (https://rk86.ru/index.html?file=https://gist.githubusercontent.com/Alikberov/8016708c5ea229da0a0e5af456965743/raw/i8080-koy-mac-emu.json).

Как можно видеть, этот процессор легко эмулируется даже на ВМ80.
(Концептуально, правда, эмуляторы устарели за прошедшие годы. Но для ознакомления - вполне подходят.)

P.S.: Далее перейду к более серьёзным работам - разработанным Verilog-моделям и "маргинальным указателям", с помощью которых появились команды LEA и XLAT.

[UncleDim]

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

[i8088]

Alikberov, а NOP какой код у Вас? А переходы?

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


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

В любом случае, автору темы желаю всяческих успехов!!

[Alikberov]

(где взять не преклонного возраста людей, согласных кодить в кодах?))Изначально всё проектировалось, чтобы ПЗУ с программой заменить на макетные платы и шестнадцатеричные тумблеры (ссылка (https://yeswitch2018.en.made-in-china.com/product/lsvJrWhGnVkj/China-Durable-Electronic-4-16-Position-Rotary-Switch-for-Remote-Control.html)) в количестве от 512 штук (под табло механического дампа на ввод программы из 256 байтов).


Alikberov, а NOP какой код у Вас?Очень любопытный вопрос!

С одной стороны, под NOP'ом может использоваться любая операция:
коды A0..D9 (REG A0..D0) для активации левого операнда-приёмника могут повторяться много раз
коды AA..DD (ARG A,A..D,D) для определения АЛУ-операндов могут повторяться много раз
коды AE..DF (CLC/CMC и т.д.) могут повторяться много раз
Но, это - только в изначальном варианте. Так как сейчас работаю над "строгим дешифратором команд", который не допускает повторения однотипных инструкций:

последовательность операций REG A7 и REG A5 составляются в одну - REG A75 (нужен регистровый файл побольше)
последовательность операций CMC и CLC, так как CMC перед CLC бессмысленна, образует новую операцию
последовательность операций CMC и CMC, так как двойная CMC бессмысленна, образует новую операцию
То есть, процессор хоть и не "нейросеть", но вполне способен в таком контексте выполнять "скрытые операции".

А переходы?Выше я привёл пример же:
код "CF" означал "NOT CF" (CMC), а с префиксом "54 CF" означает "JCF [D5+4]"
То есть, CMC с префиксом - условный переход.
Так как имеется 32 INT'а (коды E0..FF), в подпрограммах (в JavaScript-эмуляторе с "Гонками") реализованы "нормальные" JC/JNC на абсолютные адреса (или относительные).

МАРГИНАЛЫ
В знакомой всем IA-32 / x86 имеются механизмы вычисления абсолютного адреса:
LEA EBX,[EBX+EBX*2+3] - эквивалент EBX += EBX * 2 + 3
ADD EBX,[EBX+EBX*2+3] - а вот здесь такой указатель не сработает и выдаст исключение
Инженеры Intel переложили всю ответственность за использование подобных указателей на программиста. Хотя, можно было бы подправить их интерпретацию:
ADD EBX,[EBX+EBX*2+3] мог бы работать как ADD EBX,(EBX+EBX*2+3) - EBX += EBX*3+3
ADD [EBX+EBX*2+3],EBX - вот тут проблема, так как нельзя выполнить как EBX*3+3 += EBX
В таких случаях, так как "ADD EBX,[EBX+EBX*2]" использует адресацию "из ряда вон!", условно она стала обозначаться как "маргинальная".

Также в x86 инструкцию можно составить искусственно и так:
MOV EAX,CS: DS: ES: FS: GS:[EBX] - указано целых пять префиксов, четыре из которых - игнорируются (маргинальные префиксы?)
Программе это ничего путного не даст, но внутреннему отладчику исключений может нести некую закодированную информацию (в зависимости от порядка префиксов).

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

То есть, из таблицы выше, вот такие примеры:
код "CB C1 2A" означал "ADD C1,B2", а с префиксом "CB C1 54_2A" означает "ADD C1,[D5+4],B2"
код "CB C1 2A" означал "ADD C1,B2", а с префиксами "CB C1 54_58_2A" означает "ADD C1,[D5+D5+48],B2" с "маргиналом"
код "BA B2 3E" означал "EOR B2,A3", а с префиксом "BA B2 54_3E" означает "EOR B2,[D5+4],A3"
код "BA B2 3E" означал "EOR B2,A3", а с префиксами "BA B2 54_58_3E" означает "EOR B2,[D5+D5+48],A3" с "маргиналом"
То есть, количество префиксов перед инструкцией ничем не ограничивается и может достигать десятков и сотен. Правая тетрада префикса, как уже можно догадаться, как часть BCD накапливается в аккумуляторе смещения.
А вот левая - указывает на регистровую пару B:C под псевдонимом D. И если указывать нулевое смещение, можно "маргинализировать" адрес (подавлять его):
код "CB C1 50_2A" работает как "ADD C1,[D5+0],B2"
код "CB C1 50_50_2A" как "ADD C1,[D5+D5+0],B2" уже не работает: Цепочка "50_50" - "маргинальна" и указатель "подавлен". Операция работает как "ADD5 C1,B2"
код "CB C1 50_50_50_2A" как "ADD C1,[D5+D5+D5+0],B2" уже не работает: Цепочка "50_50" - "маргинальна" и указатель "подавлен", но указан в третьем префиксе. Операция работает как "ADD5 C1,[D5+0],B2"
Думаю, основную суть уже уловить можно.
Но, что такое этот "ADD5"? Как работает эта "маргинализованная" инструкция?
Лично я пока ещё не определился. Формально - это команда "внешнего АЛУ#5". Обращение к сопроцессору.
То есть, технически код "80_80_70_70_0A" как "ADD87" можно использовать с сопроцессором i8087 как "FADD" - все "маргиналы" процессор (модель на Verilog) пока никак не обрабатывает, а лишь сигнализирует на выводе "MRG" для внешнего буфера, как "M1" - машинный цикл выборки операции.

То есть, масштабируемость архитектуры уже поддерживается на самом базовом уровне.

ДЕШИФРАТОР АЛУ
Обычно в процессорах допускаются бессмысленные операции, типа "MOV A,A", "CMP A" и т.д.
Так как у меня регистр A0 выполняет функцию PSW, операции типа "ADD A0,A0" как "ADD PSW,PSW" бессмысленны и на аппаратном уровне помечаются особыми признаками.
Всего получается восемь таких признаков:
M - наличие "маргинала" перед инструкцией
V - наличие "нормального указателя"
A_rcv - используется A0/PSW как приёмник результата
D_rcv - используется Порт (Device) как приёмник результата
E - признак эквивалентности операндов ("приёмник" и "источник" - один регистр/порт)
A_trs - используется A0/PSW как источник
D_trs - используется Порт (Device) как источник
F_bit - признак не АЛУ операции - FOR/MOV

На этом фоне, с учётом всех исключений, получается солидная таблица АЛУ-команд.
Изначально их было шесть - ADD / SUB / AND / OR / EOR и MOV. А стало:
79052

Вот скриншот прогона отладки дешифратора команд на Verilog HDL:
79054
Как можно заметить, многие инструкции (ситуации) ещё не определены и появились инструкции LEA, LEX (аналог XLAT) и ORD (аналог сортировочной перестановки регистров совмещённой с SHR).

Ознакомиться с кодированием инструкций, используя сложные "указатели" и "маргиналы", можно по ссылке (https://gistpreview.github.io/?7164e7cc3b4567ca8ede49b8c7936f92).

P.S.: Нетрудно заметить, что с префиксами и "маргиналами" система команд стала значительно сложнее и серьёзнее. А как 8-битная архитектура уже близко подошла к i8086.

[vegapiratradio]

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

[CityAceE]

Как разместить картинку на форуме? (https://zx-pk.ru/threads/32687-kak-razmestit-kartinku-na-forume.html)

[Alikberov]

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

Как разместить картинку на форуме? (https://zx-pk.ru/threads/32687-kak-razmestit-kartinku-na-forume.html)
Хм...
Тогда я дам ссылки на мой github-ресурс (https://github.com/Alikberov/Koyaanisqatsi/) (с кодовым именем "Койяанискацци" - трек на modarchive.org (https://modarchive.org/index.php?request=view_by_moduleid&query=48231))...
Ссылка на Verilog-модель (https://edaplayground.com/x/3mdG) (сто раз устаревшую)


https://raw.githubusercontent.com/Alikberov/Koyaanisqatsi/master/png/Logisim_Koyaanisqatsi-decoder.png



https://raw.githubusercontent.com/Alikberov/Koyaanisqatsi/master/png/Proteus_Koyaanisqatsi-decoder.png



https://raw.githubusercontent.com/Alikberov/Koyaanisqatsi/master/Logisim/Koyaanisqatsi.png



https://raw.githubusercontent.com/Alikberov/Koyaanisqatsi/master/png/Quartus_Koyaanisqatsi-Syntez.png

Но, все эти схемы - чисто ради приличия: Редкий энтузиаст возьмётся воспроизводить эту схему из реальных номенклатурных ИМС.
(более 200 микросхем, по предварительным подсчётам)
Схемами в симуляции лично я просто убедился, что построить процессор с "дружественным машинным кодом" вполне реально.

Сейчас сосредоточился на Verilog HDL, чтобы уровень "воспроизводимости" в ПЛИС был самым доступным.

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


https://raw.githubusercontent.com/Alikberov/Koyaanisqatsi/master/png/alu_excludes.png


https://raw.githubusercontent.com/Alikberov/Koyaanisqatsi/master/png/vector_calculator.png


https://raw.githubusercontent.com/Alikberov/Koyaanisqatsi/master/png/alu_execution.png


Эзотерика бинарных полей
В i8080 инструкции MOV Rd,Rt кодируются бинарным полем 01dddttt.
Тем самым, хоть даже процессор официально - индустриальный и не эзотерический, эту самую эзотерику несут битовые поля в кодировке инструкций.
Позволю себе промолчать и про все остальные: IA-32, ARM и т.д.

Почти "Java-машина"
Выше дана ссылка на эмулятор процессора для РАДИО-86РК.
А если он достаточно легко эмулируется на РЛК, то можно написать эмулятор и на ZX-Spectrum, и на Yamaha-MSX.
То есть, получаем "подобие Java-машины", только с "гуманитарным машинным кодом", который не нужно выучивать и зубрить таблицу команд.

Как можно убедиться, аккумуляторов может быть 10 (A0..A9), так и 100 (A10..A99) или даже тысяча (A100..A999). На программном уровне это доступно.
В таком случае общее количество РОН становится не 30, а 300 и 3000 соответственно.
(Если браться собирать процессор "по военному" - на отдельных модулях, то нет никаких архитектурных ограничений на масштабируемость.)

При "прошивке FPGA" вполне можно указать размер Регистрового Файла, какой только способен уместиться на ПЛИС.
(Существовал вариант, где всё архитектурное состояние сохранялось непосредственно в ОЗУ, что могло обеспечить многозадачность, но требует до 10 Машинных Циклов на операцию - до 30 тактов.)

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

Некоторые проблемы "парадигмы"
Выше уже указывалось, что оп-коды E0..FF - это "заглушки" программных INT'ов, проще говоря - CALL E000..FF00.
Однако, так они работают только в "сухом виде" - без префиксов (указателей и "маргиналов").
До сих пор отсутствуют представления о том, как должны работать "указательные INT'ы" и "маргинальные INT'ы".
А ещё:
Указательные-Маргинальные CLC/CMC
Указательные/Маргинальные ARG
Маргинальный HLT
Всё это указывается на "скрытый потенциал архитектуры", о котором я не подозревал в 2019 году на первых набросках схематики в Logisim.
Даже на высоком уровне - в JavaScript, просто не имеется никакого чёткого представления, как обрабатывать "маргинализацию" существующих команд.
(Пока она просто игнорируется или выполняет "действительно маргинальные операции" из ряда вон: Чертит линии и выводит спрайты, что никак не должно распространяться за пределы экспериментальной эмуляции.)

P.S.: Всё это - результат двадцатилетних исследований.

[Alikberov]

ТЕ ЕЩЁ МАРГИНАЛЫ
Как сказано выше, указание неверного указателя на аппаратном уровне обрабатываются в особенном виде, из-за чего программист может использовать эти резервные механизмы по своему усмотрению.
Однако, эти самые маргиналы местами просто слишком маргинальны.
Например, рассмотрим несколько странных инструкций:

код «00» - команда останова «HLT»: Переход на адрес 0000 с сохранением точки останова в D0 (регистровой паре B0:C0)
код «10 00» - команда останова «HLT [D1+0]»: Безусловный переход на адрес [D1] с сохранением точки останова в D0
код «10 10 00» - команда останова «HLT1» или «HLT#1»: Здесь присутствует маргинал - непонятная операция…
код «10 10 10 00» - команда останова «HLT 1#D1+0» или «HLT 1#[D1+0]»: Присутствует маргинальный указатель - ещё страннее…

Нетрудно заметить, что на одной только операции Останова с частной комбинацией префиксов уже довольно неясная ситуация. Даже если браться обрабатывать такие комбинации на самом высоком уровне - эмуляцией в JavaScript, не совсем понятно, что именно с этим безобразием делать…

МАРГИНАЛЬНЫЕ КАНАЛЫ
Так как «маргинальные индексы» временно помечались в ассемблере/дизассемблере с «решёткой-шарпом», то это напомнило некоторую аналогию с каналами в Бейсиках (как каналы и потоки ZX-Spectrum (https://worldofspectrum.org/faq/reference/48kreference.htm)).
Так, есть такой GW-Basic - оператор OPEN (https://hwiegman.home.xs4all.nl/gw-man/OPEN.html) - вполне хороший пример.

Тем самым, вполне можно:

код «10 10 00» - команду «HLT#1» можно условно обозначать за «CLOSE#1»…
код «10 10 10 00» - команду «HLT#1 [D1]» можно условно обозначать за «OPEN#1 "/dev/…"»…

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

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

МАРГИНАЛЬНАЯ ЭМУЛЯЦИЯ КАНАЛОВ
Естественно, о поддержке «маргинального окружения» на аппаратном уровне думать не приходится в принципе!
Тем самым, следует продумать механизмы прерываний, чтобы поддерживать все эти «маргинальные каналы» на программном уровне драйверов операционной системы.
Ещё во времена DOS и IBM PC-XT существовали библиотеки эмуляции отсутствующего FPU. Здесь - примерно то же самое…

ПРИМЕР
Если мы настроили «Маргинал #1» указателем на строку, типа "/dev/ega/320x240/" как открытия непосредственной проекции EGA-графики, тогда

10 10 80 90 80 80 90 80 80 80 80 80 80 A7
будет означать «MOV 1#[D8+320D9],A7», что буквально «*(BYTE *)(D8 + 320 * D9) = A7», где D8 - координата X и D9 - координата Y.
Получается одна длинная операция пиксельной записи в графическую плоскость.

P.S.: Если достаточно внимательно отнестись к описываемой здесь концепции процессора, можно подметить, насколько эта архитектура проста, но одновременно и противоречива (в хорошем смысле).
За четыре года наработок в этом направлении мною обнаруживается множество скрытых потенциалов, которые в принципе можно реализовать и на уровне Verilog HDL, что позволит в конечном счёте иметь достаточно мощный 8-битный процессор с гибкой архитектурой.

[Alikberov]

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

7F 78 79 7A 7Bкак цепочка
MOV A,A
MOV A,B
MOV A,C
MOV A,D
MOV A,EПросто бессмысленна и работает чисто декоративными NOP'ами на 20 тактов перед ключевой «MOV A,E».
Чисто гипотетически можно представить инструкцией «MOV A,ABCDE» с операндом «ABCDE» в качестве регистра-транслятора…
Процессор просто последовательно выполняет цепочку команд, не задумываясь дальше одной операции.

А что, если…

Научить дешифратор команд учитывать предыдущий код?

РЕЗИНОВЫЙ РЕГИСТРОВЫЙ ФАЙЛ
Для читателя темы, который уже чуточку вник в парадигму архитектуры, будет легче понять кодирование инструкций.

Приведу небольшой пример…
Как написано в самом начале, шестнадцатеричные коды A0…A9 служат для выборки конкретного одноимённого аккумулятора.

код «A1» активирует регистр-аккумулятор A1
код «A1 A2» активирует сначала регистр-аккумулятор A1, а затем активирует A2
код «A1 A2 A3» активирует сначала регистр-аккумулятор A1, а затем активирует A2, но в конце-концов активирует A3
Что происходит? Это - те самые любимые NOP'ы???
Так быть не должно: Эзотерикой пахнуть просто недопустимо!

Так, при добавлении довольно нехитрой процедуры проверки ближайшего недавнего кода, дешифратор команд теперь может аккумулировать индексы самого регистра:
код «A1 A2» активирует регистр-аккумулятор A12
код «A1 A2 A3» активирует регистр-аккумулятор A123
Продолжив совершенствовать дешифратор команд, можно ключевую команду доработать в том же ключе:
код «6F» является командой «MOV A123,A6»
код «6F 7F» является сначала командой «MOV A123,A6», а затем «MOV A123,A7»
код «6F 7F 8F» является сначала командой «MOV A123,A6», а затем «MOV A123,A7», но в конце-концов «MOV A123,A8»
Теперь такой поток команд интерпретируется как:
код «6F» является командой «MOV A123,A6»
код «6F 7F» является командой «MOV A123,A67»
код «6F 7F 8F» является командой «MOV A123,A678»

Тем самым, теперь можно сказать:
A1 A2 A3 A4 A5 6F 7F 8F 9F 0FЭто составная инструкция «MOV A12345,A67890»…

То есть, процессор хоть и 8-битный, но количество регистров в нём практически ничем не ограничивается и может достигать сотен, тысяч и миллионов…

P.S.: Новое слово в концепции «процессорных секций»???

[vegapiratradio]

любопытный процессор получается!
будет готовая модель на верилог? компилятор для PC?

[AlexG]

А что, если…

Научить дешифратор команд учитывать предыдущий код?


То есть, процессор хоть и 8-битный, но количество регистров в нём практически ничем не ограничивается и может достигать сотен, тысяч и миллионов…

P.S.: Новое слово в концепции «процессорных секций»???
"Всё украдено до нас" все эти фичи уже придуманы и реализованы в современных процессорах. гугл в "теме"...

[Alikberov]

"Всё украдено до нас" все эти фичи уже придуманы и реализованы в современных процессорах. гугл в "теме"...Да, я, кажется, в курсе: Все эти конвейеры, суперскалярности и пр…
Речь идёт именно о чистом 8-битном CISC (без суперскалярного RISC-ядра внутри).

И, теоретически, его на ИМС ТТЛ собрать можно.
Конечно, он будет побольше схемы того же «Микро-80», но, как можно заметить, архитектура - масштабируема в обе стороны: Можно выполнить и с 4-разрядными РОН на К1533ИР39 (http://www.radio-komplekt.ru/im/labels2/1533%D0%98%D0%A039.pdf)…

[Sandro]

То есть, процессор хоть и 8-битный, но количество регистров в нём практически ничем не ограничивается и может достигать сотен, тысяч и миллионов…

P.S.: Новое слово в концепции «процессорных секций»???

GCC ещё в прошлом веке компилировал для виртуальной машины с 4G регистров, а потом отображал виртуальные регистры на физические, а что не влезло -- на стек. Сейчас в любом ведрофоне Dalvik с той же концепцией. А зачатки -- это ещё доисторический ископаемый SPARC, а точнее -- Berkeley RISC Machine, скоро полвека ей ужё будет.

Историю надо знать.

[AlexG]

абсолютно НЕ важно какая разрядность и вид команд - от слова СОВСЕМ. к примеру кеш-память применяли как минимум в 70г.

[Alikberov]

любопытный процессор получается!
будет готовая модель на верилог? компилятор для PC?Сейчас я над этим и работаю (в зомби-режиме - жарко очень), так как Гугл-Силикон (https://developers.google.com/silicon) пока ещё принимает заявки…

А с другой стороны, как бы там ни было, а тема посвящена именно Концептуальному Процессору!

Т.е. процессор разрабатывается именно как с дружелюбным машинным кодом, в стиле WYSIWYG (что видите - то имеете) жанра "Акына" (что вижу - то и пою)…

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

Только в свете новых открытий (маргиналов и безразмерного регистрового файла) ещё JavaScript-эмулятор подтянуть надо, так как это какой-то «8-битный мэйнфрейм» получается (привет, CRAY!)…

P.S.: Те, кто «в теме» (дамп-кодирования) - поймут и тему подхватят…
0000 DD D3 08 3F LEA D3,TEXT
0005 F8 18 INT F818
0007 00 HLT
0008 48 45 4C 4C 4F 00 TEXT: DB "HELLO",0А большего и не ожидается…
Эмулятор на BASH: 79129
(Клавиша F7 - строчный ассемблер)

[Alikberov]

Те, кто «в теме» (дамп-кодирования) - поймут и тему подхватят…
0000 DD D3 08 3F LEA D3,TEXT
0005 F8 18 INT F818
0007 00 HLT
0008 48 45 4C 4C 4F 00 TEXT: DB "HELLO",0Для тех, кто дружит с Raspberry Pi и его богатым периферийным интерфейсом, был написан черновой вариант эмулятора на BASH: 79129

F1 - Справка
F2 - Режим "классический" и "стандартный"
F3 - Один шаг эмуляции/отладчика
F4 - Редактор дампа ОЗУ (встроенный)
Shift+F4 - редактор дампа файла ПЗУ (внешним hexcurse)
F5 - Сброс эмуляции
F6 - Исполнение кода до команды HLT
F7 - Строчный ассемблер с записью кода команды на текущую позицию IP
Конечно, эмулятор ещё не отлажен и не полный. Но базовые принципы понять позволяет.
Ограниченно и с глюками поддерживает указатели и маргиналы.

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

[Alikberov]

Благодаря расширению доступности нейросетей DeepSeekChatGPT в этом году удалось концептуально продвинуться.

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

WYSIWISC - What You See Is What It Should Compute (Что Видите, То Вычисляете)
Аналогично WYSIWYG, но более низкого фундаментального уровня.

И помогла упаковать всё описание процессора в шаблон:
Условные сокращения:
1. io = 0xio, где i, o — BCD.
1.1. HLT/JMP (= 0x00).
1.1.1. Без префикса: IP → D0, IP ← 0x0000 (вызов БСВВ).
1.1.2. С префиксом `#Di+o`: D0 ← IP, IP ← Di+o (JMP).
1.2. Префиксы `#Di+o` (`[Di+o]`) (≠ 0x00).
2. TS = 0xTS, где T, S ∈ {0xA, 0xB, 0xC, 0xD}.
2.1. TR = TS, но S ≠ T.
2.2. TN = TS, но S = T.
3. Tn = 0xTn допускается после TS, если T совпадает с T из TS.
3.1. Tm = Tn Tn ... допускается после TS, если T совпадает с T из TS.
3.2. Выбирает T за основной операнд.
4. Rn = 0xRn допускается после TS, если R ≠ T из TS.
4.1. Rm = агрегация Rn Rn ... допускается после TS, если R ≠ T из TS.
4.2. Загружает R в основной операнд.
5. vF → Загружает Nv в T, если контекст TN.
5.1. wF = агрегация vF vF ... → Загружает Nw в T, если контекст TN.
6. vF → Сохраняет T в Rv, если контекст TR.
7. vU = 0xnU, где v — BCD, U ∈ {0xA–0xE}.
7.1. v → индекс S в контексте TS.
7.2. если T в TS = A и Rn = A0, U → {INC, DEC, CLR, SET, EOR}
7.3. если S в TS = A, 0U → {INC, DEC, CLR, SET, EOR} с условием CF
7.4. в остальных случаях U → ADC, SBB, AND, OR, EOR

Архитектура:
1. Регистр A0 → PSW.
1.1. Биты 0, 1, 2, 3 → флаги ZF/DF, CF, VF/BF, NF/AF.
1.1.1. Без префикса - управление флагами.
1.1.1.1. 0xCE → CLC (Carry Erase)
1.1.1.2. 0xCF → CMC (Carry Flip)
1.1.1.3. 0xAE → CLA (Absolute Erase)
1.1.2. С префиксами - управление потоком.
1.1.2.1. 0x12 0xCE → JNC #D1+2
1.6. Не операнд АЛУ.
1.6.1. TS = AX, Rn = A0 → vU унарная (INC, DEC, CLR, SET, NOT).
1.6.2. TS = XA → 0U условная унарная (INC, DEC, CLR, SET, NOT).
2. Регистр D0...D9
2.1. Регистровые пары B0C0...B9C9

Стек:
1. Реализуется пользователем, указатель — любой удобный регистр.
2. D0 ← IP при JMP/HLT, подпрограммы должны сохранять D0.
3. RET = JMP #D0+1.Можно заметить, что в отличии от множества известных архитектур (INTEL, MOTOROLA, SUN), которые так кратко не уместишь в описательный шаблон, здесь WYSIWISC описывается практически полностью (за исключением префиксов).

С кодированием префиксов нейросеть так и не смогла справиться, хотя логика там не такая сложная (онлайн вариант (https://alikberov.github.io/wysiwisc/delegate.html) и для эмулятора 82395).

Но, нейросеть помогла подобрать условному термину маргиналы более понятный - делегаты.

Делегат
Говоря простым языком,делегат - это удалённый префикс, который подставляется в текущую инструкцию по ссылке, адресуемой любой регистровой парой.

90 90 80 80 76 54 32 10 00 DEF 98#D7+D5+D3+D1+6420 LEA D98,[<D7+D5+D3+D1+6420>]
12 34 56 78 90 A1 MOV #D1+D3+D5+D7+D9+24680,A1 MOV [D1+D3+D5+D7+D9+24680],A1
90 90 80 80 A2 MOV 98#,A2 MOV [<D7+D5+D3+D1+6420>],A2
90 90 80 80 12 34 56 78 90 A3 MOV 98#D1+D3+D5+D7+D9+24680,A3 аналогично MOV ES,D98 и MOV ES:[D1+D3+D5+D7+D9+24680],A3
90 90 80 80 12 34 56 78 90 CE JNC 98#D1+D3+D5+D7+D9+24680 MOV PSW,[<D7+D5+D3+D1+6420>] и JNC #D1+D3+D5+D7+D9+24680Нейросеть как бы и понимает общие принципы работы делегатов, но не может в своём опыте (БД) найти нечто подобное в известных ей десятках архитектур.

Рассмотрим на примерах:
«HLT #D7+6» → «JMP #D7+6» → Останов текущей цепочки инструкций с ветвлением на вектор
«HLT 8#D7+6» → «DEF 8#D7+6» → Операция останова работает как предопределение регистра - «D8 = IP»
«HLT 8#» → «DBG 8#» → Операция останова работает как прерывание на отладку удалённой инструкции
«MOV A9,#D7+6» → «MOV A9,[D7+6]» → Чтение ячейки локальной памяти
«MOV A9,8#» → «MOV A9,[CALL D8]» → Чтение ячейки по вектору, который предопределил «DEF» (аналогично «DBG», но выполняется только префикс)
«MOV A9,8#D7+6» → «MOV A9,D8:[D7+6]» → Обращение к сегменту глобальной памяти

В общем, понять более-менее можно, думаю.

P.S.: Как видите, всё достаточно необычно и нейросеть спотыкается по любому пустяку. Просит показать ей 100500 примеров как надо и как не надо кодировать, чтобы обучиться данной архитектуре.

[andrews]

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

[Alikberov]

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

Вопрос только в том, что когда Вы ее чему-то новому научите не станет ли это доступно всем?Полагаете, идею могут украсть?:D
В DeepSeek нету групповых сессий.

Кстати DeepSeek довольно хорошо умеет писать кросс-ассемблеры и простые консольные симуляторы. Другое я пока не успел попробовать.Я пытался на РК синтезатор голоса на уровне гласных реализовать под четыре форманты.

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

Но вот с WYSIWISC она не справляется. В частности, LLVM backend под WYSIWISC получается слишком сложным из-за множества нюансов.
Да и контекст постоянно теряет.
С префиксами и делегатами - вообще всё слишком сложно.

Конкретно под тему - разработал/отладил узел обработки префиксов.
https://esolangs.org/w/images/a/ab/Prefixes_order_controller_%28SN74xx%29.png

https://youtu.be/LXNr6C9K8Yg

P.S.: Вообще, прожект продвигается крайне тяжело.
Очень много противоречий в нём: Архитектура - 8-битная, адресация - 16-битная или 32-битная с делегатами.
Например, нейросеть не представляет принцип т.н. разыменования некоторых указателей, что мешает разработке полного эмулятора.

[andrews]

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

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


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

[Alikberov]

входил сам под разными аккаунтами и во второй раз начинал с результатов, полученных после многих итераций на первом аккаунте и DeepSeek продолжал уже не с "нуля" и довольно быстро пришел к требуемому результату.Может всё дело в т.н. температуре?
Если в начале сессии указать "максимальную температуру", нейронка будет иметь вольнодумства в процессе мышления.

если вы предлагаете что-то новое, то он уясняет не сразу, а после нескольких итераций. Иногда, кстати, зацикливается, и надо проявить изобретательностьПредстав лял ей готовые модули на JavaScript и Verilog. Притворяется, что "теперь всё понятно", но всё также допускает грубые ошибки.

Исходный текст шаблона таков:
Условные сокращения числовых индексов:
- "i" - цифра от 0 до 9 для указания индекса регистра-индекса/базы;
- "o" - цифра от 0 до 9 для накопительного указания относительного смещения;
- "n" - цифра от 0 до 9;
- "v" - цифра от 0 до 9;
- "m" - число от 00 и выше, количество разрядов не ограничено:
- каждая цифра числа последовательно конкатенируется в цепочку однотипных операций.
- "w" - число от 00 и выше, количество разрядов не ограничено:
- каждая цифра числа последовательно конкатенируется в цепочку однотипных операций.

Условные сокращения регистров и регистровых групп:
- Обобщение:
- "R" - регистр-приёмник / "Receiver" → R ∈ {"A", "B", "C" или "D"} (0xA-0xD в старшем ниббле);
- "T" - регистр-транслятор / "Translator" → T ∈ {"A", "B", "C" или "D"} (0xA-0xD в младшем ниббле).
- Особые случаи:
- "G" - псевдоним "T", где регистр-источник из группы регистра-приёмника (`ARG R,G`, где G ∈ R):
- формальная FOR-пересылка из регистра-транслятора в регистр-приёмник;
- служебная команда REG устанавливает индекс регистра-приёмника;
- служебные команды REG в непрерывной цепочке - расширяют индекс регистра-приёмника.
- "S" - псевдоним "T", где регистр-источник/спасатель не из группы регистра-приёмника (`ARG R,S`, где S ∉ R):
- может работать как регистр-источник или регистр-спасатель;
- формальное FOR-сохранение регистра-приёмника в регистр-транслятор;
- служебная команда REG работает как инструкция MOV;
- служебные команды REG в непрерывной цепочке - расширяют индекс регистра-источника.
- "P" - набор префиксов и указателей адреса "Pointer":
- используются регистры группы "D".

Основное правило:
- принцип WYSIWYG:
- Семантическое кодирование кода инструкции всегда имеет соответствующую ассоциативную смысловую нагрузку:
- Необходимо соблюдать семантику операций, зашифрованную в визуальном представлении кода;
- Шестнадцатеричное визуальное представление 8-битного машинного кода влияет на смысл и логику действия инструкции;
- Имена регистров кодируются аналогичным кодом в служебных командах:
- Две регистровые группы приёмника и транслятора - `RT`:
- Служебная команда "ARG R,T", "ARG R,G" или "ARG R,S" управляют контекстом:
- Предопределяет операнды всех последующих операций АЛУ;
- Предопределяет контекст всех последующих операций АЛУ, REG и MOV;
- Последующие команды наследуют контекст до очередного предопределения;
- Кодируется нибблами регистровых групп;
- Допускается указание "ARG R,R", где регистр-приёмник и регистр транслятор находятся в одной группе.
- Служебная команда "ARG Rn/m,T", "ARG Rn/m,G" или "ARG Rn/m,S" управляют контекстом и предопределяет регистр-приёмник Rn или Rm:
- Расширенный синтаксис, где после "ARG" следует "REG Rn" или "REG Rm".
- Имя регистра-приёмника с цифровым `Rn` или многозначным `Rm+` индексом:
- Служебная команда "REG Rn";
- Цепочка служебных команд "REG Rm"+ производит последовательную конкатенацию индекса "nm..."+:
- Последовательные команды "REG" конкатенируют цифры индекса в порядке их появления - слева направо.
- Последующие команды работают с заданным регистром "Rn" или "Rm+";
- Кодируется именем самого регистра.
- Две регистровые группы индексированного приёмника и транслятора - `RT Rn` или `RT Rm+`:
1. Служебная команда "ARG R,T", "ARG R,G" или "ARG R,S";
2. Одна служебная команда "REG Rn";
3. И цепочка из служебных команд "REG Rm"+ далее, если требуется.
- Пересылка в регистр-приёмник из регистров других групп:
- Кодируются именами регистров-источников:
- Команда "MOV Rn,Sv" → Пересылка из Sv в Rn;
- Цепочка команд "MOV Rn,Sw" расширяет индекс источника конкатенацией цифр w в порядке их появления.
- Регистры кодируются нибблами, соответствующие их именам.
- Тем самым, каждый код следует осмысленно интерпретировать как аббревиатуру из двух нибблов:
- Индекс регистра-транслятора (v) и имя операции (U) - код "vU" операции АЛУ (приёмник,источник):
- Допустимые базовые операции:
- Имя операции - семантическая ассоциативная буква младшего ниббла (U ∈ "A".."E"):
- Сложение (A) с переносом и Вычитание (B) с займом:
- Для операций сложения и вычитания без займа:
- Требуется команда "CLC".
- Конъюнкция (C) побитовая и Дизъюнкция (D) побитовая;
- Исключающее ИЛИ (E).
- Индекс регистра-транслятора (v или w) и младший ниббл `F`:
- Старший ниббл (v или w) определяет индекс регистр-источника:
- Контекст (G/S) зависит от типа ARG (R,G или R,S).
- Форсированная пересылка в контексте "ARG R,T":
- MOV Sv,Rn → Пересылка из Rn (R) в Sv (S ∉ R);
- MOV Rn,Gv → Пересылка в Rn из Gv (G ∈ R):
- Если выбран контекст "R,R";
- В активный регистр-приёмник из "Gv" или, конкатенацией, из "Gvw..."+.
- Вектор программного прерывания на адрес, старший байт которого является кодом инструкции:
- Команда "INT E0..FF" - вызов подпрограммы по адресу E000..FF00;
- Команда "HLT" - частный случай прерывания "INT 00" с кодом "00";
- Команда "JMP #Di+o" - частный случай "HLT" с префиксами адреса.
- Управление флажками PSW:
- Бит 0 - флаг "DF" ("Different Flag"), признак "разницы" (аналогичен флагу ZF);
- Бит 1 - флаг "CF" ("Carry Flag"), признак "переноса" (аналогичен флагу CF);
- Бит 2 - флаг "BF" ("Biggest Flag"), признак "переполнения" (аналогичен флагу OF);
- Бит 3 - флаг "AF" ("Absolute Flag"), признак "абсолютного числа" (аналогичен флагу SF).
- Имя флага кодируется в код инструкции:
- Без префиксов:
- "CF": "Carry Flip" - аналогичен "CMC";
- "CE": "Carry Erase" - аналогичен "CLC":
- Требуется операциям "ADC"/"SBB" для выполнения "ADD"/"SUB".
- С префиксами адреса образуются аналогичные инструкции условного ветвления, как "JMP":
- "io CF": "Jump if Carry Flipped" - аналогичен "JCF/JC #Di+o";
- "io CE": "Jump if Carry Erased" - аналогичен "JCE/JNC #Di+o".
- Префикс кодируется двумя цифровыми нибблами "io" и составляет вектор:
- Интерпретируется как:
- `#Di+[nDj+mDk+...]+o`, где:
- `Di` - базовый регистр (первый префикс);
- `n`, `m` и т.д. - коэффициенты индексных регистров;
- `o` - конкатенация всех цифр "o" из префиксов (ведущие нули отбрасываются);
- `#` - маркер регистра базы (всегда коэффициент "1").
- Правила:
- Лидирующий регистр базы:
- Помечается как регистр базы "#Di";
- Всегда имеет коэффициент "+1";
- Открывает пустой уровень суммы вкладов индексных регистров:
- `#Di+(0)+o`.
- Повторяющийся регистр базы "Di":
- Не может в цепочке далее приращиваться к индексной сумме;
- Не изменяет собственного коэффициента;
- Рекурсивно масштабирует с коэффициентом 2 все текущие вхождения индексных регистров:
- Каждое повторение базового регистра масштабирует текущие коэффициенты индексных регистров на 2. Новые индексы, добавленные после этого, имеют коэффициент 1.
- Индексные регистры:
- Новые индексы добавляются с коэффициентом "+1".
- Первое вхождение регистра:
- Делает вклад в сумму с коэффициентом "+1";
- Повторное вхождение регистра:
- Проверяется коэффициент вклада в индексную сумму:
- При чётном коэффициенте:
- Инкриминирует его коэффициент на единицу.
- При нечётном коэффициенте:
- Все текущие коэффициенты индексного ряда рекурсивно масштабируются на 2;
- Инкриминирует его коэффициент на единицу.
- Цифры "o" относительного смещения:
- Последовательным набором разрядов отдельным членом выражения представляют десятичное число поизвольной длины;
- Накапливаются последовательным, слева-направо, набором конкатенации в десятичном смещении вектора;
- Являются отдельным членом выражения относительного смещения;
- Не зависят от комбинаций регистров базы и индексов в цепочке;
- Не оказывают влияние на коэффициенты индексных регистров.
- Количество префиксов перед любой операцией не ограничивается.
- Математическая модель адреса:
- Адрес = #Di + Σ(k_j * D_j) + o, где:
- k_j = 2^m * (n_j),
- m — количество повторений базового регистра Di,
- n_j — количество добавлений Dj с учётом чётности.
- Алгоритм кодирования:
- Для коэффициента k_j:
- Представить k_j в двоичной форме:
- Каждое вхождение 1 в младшем разряде соответствует добавлению Dj с масштабированием.
- Пример для 18D2:
- 18 = 2^4 + 2^1 → цепочка: 20 → 10 → 28 → 10 → 28 → 10 → 28.Нейросеть, соответственно, оптимизировала его по токенам и сжала до:
Условные сокращения:
1. io = 0xio, где i, o — BCD.
1.1. HLT/JMP (= 0x00).
1.1.1. Без префикса: IP → D0, IP ← 0x0000 (вызов БСВВ).
1.1.2. С префиксом `#Di+o`: D0 ← IP, IP ← Di+o (JMP).
1.2. Префиксы `#Di+o` (`[Di+o]`) (≠ 0x00).
2. TS = 0xTS, где T, S ∈ {0xA, 0xB, 0xC, 0xD}.
2.1. TR = TS, но S ≠ T.
2.2. TN = TS, но S = T.
3. Tn = 0xTn допускается после TS, если T совпадает с T из TS.
3.1. Tm = Tn Tn ... допускается после TS, если T совпадает с T из TS.
3.2. Выбирает T за основной операнд.
4. Rn = 0xRn допускается после TS, если R ≠ T из TS.
4.1. Rm = агрегация Rn Rn ... допускается после TS, если R ≠ T из TS.
4.2. Загружает R в основной операнд.
5. vF → Загружает Nv в T, если контекст TN.
5.1. wF = агрегация vF vF ... → Загружает Nw в T, если контекст TN.
6. vF → Сохраняет T в Rv, если контекст TR.
7. vU = 0xnU, где v — BCD, U ∈ {0xA–0xE}.
7.1. v → индекс S в контексте TS.
7.2. если T в TS = A и Rn = A0, U → {INC, DEC, CLR, SET, EOR}
7.3. если S в TS = A, 0U → {INC, DEC, CLR, SET, EOR} с условием CF
7.4. в остальных случаях U → ADC, SBB, AND, OR, EOR

Архитектура:
1. Регистр A0 → PSW.
1.1. Биты 0, 1, 2, 3 → флаги ZF/DF, CF, VF/BF, NF/AF.
1.1.1. Без префикса - управление флагами.
1.1.1.1. 0xCE → CLC (Carry Erase)
1.1.1.2. 0xCF → CMC (Carry Flip)
1.1.1.3. 0xAE → CLA (Absolute Erase)
1.1.2. С префиксами - управление потоком.
1.1.2.1. 0x12 0xCE → JNC #D1+2
1.6. Не операнд АЛУ.
1.6.1. TS = AX, Rn = A0 → vU унарная (INC, DEC, CLR, SET, NOT).
1.6.2. TS = XA → 0U условная унарная (INC, DEC, CLR, SET, NOT).
2. Регистр D0...D9
2.1. Регистровые пары B0C0...B9C9Я уж думал - победа!
Но ничего существенно не изменилось.

Одна из проблем - потеря контекста:
AB A1 B2 → MOV A1,B2
;;;;;;;;;;;;;;;;;;;;;;
AB → CTX A,B ; Контекст: Приёмник A, Источник B
A1 → REG A1 ; Конкретно Регистр A1
B2 → MOV A1,B2 ; Пересылка (не REG B2, так как Приёмник - группа A).И нейросеть постоянно забывает, что если Источник и Приёмник не менялись, атомарную инструкцию CTX указывать не стоит, как и атомарный REG, если индекс Приёмника не меняется.
Пустячок, правда? Однако, нейросеть жалуется на то, что ни в одной из знакомых ей архитектур действие атомарных инструкций не может распространяться на сотни последующих. Из-за чего она в стратегическом планировании кода путается.
И это - малая доля сложностей.
Ещё нейронка говорит, что самому человеку в уме легко держать текущий контекст, так как интуитивнно это очевидно. А нейросети приходится постоянно пересматривать код.

[andrews]

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

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

[Alikberov]

Надо разжевывать очевидное. Если начинает циклиться, удалять этот чат, сохранив себе нужные результаты и открывать новый чат. Подозреваю, что таким способом можно уничтожать причины, по которым она "зацикливается".Да-да, именно так я и делал.
У меня было с десяток новых сессий, пока я учился конкретно формулировать запросы, включая туда наиболее удачные моменты.

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

[andrews]

Я бы опробовал все конструкции русского языка. Например: "почему ты не хочешь понять, что во-первых..." и т.д. Проверял усвоение знаний контрольными вопросами, возможно с выбором вариантов( верный и не верный). "Ты сделала неправильный выбор, потому что..." "Сколько раз тебе говорить, что..." "Даже мне понятно, что..." "Объясни, что непонятного в том, что..." ну и т.д. и т.п. Как будто бы перед Вами туповатый и/или ленивый ученик. И не закрывайте чат, в котором она показала понимание. Мне не известно, переходит ли полученное знание на все открытые чаты в аккаунте или нет.

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

"Меня моя версия вполне устраивает. Она оттестирована и рабочая"
После чего последовало:
"Отлично! Если ваша версия процедуры деления работает корректно и прошла тестирование, оставлю её без изменений. Вот полный код zxcc.cpp с вашей рабочей версией деления"

[Alikberov]

Я бы опробовал все конструкции русского языкаВ конце-концов я лишний раз убедился, что нейронка может помочь лишь в подборе корректных терминологий (делегаты точнее отражают суть, чем маргиналы) и обратить внимание на то, что годами не привлекало внимания (ссылки, где делегат и база - один регистр: Примерно как «MOV AX,BX:»).

[B]Общее представление о делегатах
Для ясности, в качестве примера возьмём самую популярную архитектуру - Intel x86.
Так как сегментные регистры CS: DS: ES: FS: GS: SS: не являются ортогональными РОН, для упрощения буду успользовать вольную адресацию.

Например, здесь «MOV AL,DX:» - регистр DX работает в качестве сегментного.
Однако, нейронка спросила, как интерпретировать инструкцию «MOV AL,BX:[BX+1]», где регистр BX - и сегмент, и база?
И вот эта ситуация поставила меня в тупик.

В классике жанра, нейросеть предложила просто вырабатывать исключение в таких случаях. Однако, это - не мой метод, так как дешифратор команд имеет сложную эвристику, чтобы избежать исключений.
Например, аналогичное «ADD AX,FX» - это просто «INC AX», так как регистр признаков FX игнорируется и отбрасывается.
Аналогично как и «ADD FX,AX», где нельзя с флагами проводить непосредственные операции АЛУ: Это «CINC AX» - условный INC по признаку CF. То есть, «ADD AX,CF».

Таким образом, инструкция «MOV DX:[DX+CX*12+3],BX» должна тоже что-то полезное выполнять, а не генерировать исключение по пустякам.

[B]Адресация делегатами
Если в x86 вектор «ES:[BX]» формирует -20-битный адрес ((ES<<4)+BX), у меня шина адреса - 16-битная.
Но, регистр сегмента выдаётся как адрес отдельным сигналом (BX по сигналу ALE, ES по сигналу делегирования DEL).
То есть, если аппаратно система работает только с ALE, инструкции с делегированием адресного пространства не будут работать с 4 Гб памяти внешней периферии.
А если DEL учитывается, то по DEL формируется индекс УВВ (65536 УВВ страницами по 65536 ячеек - 4 Гб), что позволяет в 8-битной среде с 16-битной адресацией через регистровые пары формировать 32-разрядный адрес.

Согласитесь: Это довольно необычно.

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

P.S.: Просто нужно сесть и попытаться написать очередной WYSIWISC-эмулятор с учётом достигнутых соображений.
А потом - посмотреть, как интерпретировать все эти странные инструкции.

[CodeMaster]

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

[Alikberov]

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

Начнём с самого простого: Инструкции с машинным кодом 0x00:
i8080 / z80 - NOP (вполне очевидное и интуитивно понятное соответствие)
i8086 / x86 - ADD (соответствие вообще не очевидно)
MOS 6502 - BRK (вполне очевидное и интуитивно понятное соответствие)
MIPS - NOP (вполне очевидное и интуитивно понятное соответствие)
MOS 68000 - неопределённая инструкция / исключение (вполне очевидное и интуитивно понятное соответствие)
То есть, в большинстве архитектур нулевой код несёт предсказуемое поведение процессора, за исключением x86 с его ADD:v2_dizzy_facepalm:

После просмотра фильма "День независимости (https://www.kinopoisk.ru/film/2022/)", а позже - Трансформеров (https://www.kinopoisk.ru/film/81288/) с их эпическим заявлением, что современные процессоры - тупо копируются с инопланетных:v2_dizzy_facepalm::v2_diz zy_facepalm::v2_dizzy_facepalm:
Я задумался, а какой могла быть система кодирования инструкций в идеальном случае?

Исключаем "эзотерику битовых полей"
Расставляем инструкции в таблице стройными блоками
Делаем акцент на интуитивное понимание кода


Как представитель цивилизации Планеты Земля с бытовой десятичной системой счисления, я разработал дешифратор команд именно с основанием 10 и получил шесть блоков инструкций:
CTX - Селектор контекста
REG - Селектор регистра
FLG - Управление флажками
ALU - Операции АЛУ
HLT/INT - Программное прерывание
DLG - Делегаты / Префиксы вектора

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

Ведь индустриально мы давно преодолели практические трудности построения ЭВМ и пора бы задуматься об эстетики машинного кода.:v2_dizzy_punk:

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

[Alikberov]

Есть одна мысль с вынесением всего архитектурного состояния из ядра во внешнюю память.

Считывается из памяти значение Счётчика Команд PC
Считывается код команды по адресу PC
Считываются из памяти нужные РОН / PSW
Выполняется команда
Сохраняются в память все изменённые РОН / PSW
Сохраняется в память Счётчик Команд PC

Тем самым, переключая страницы ОЗУ можно легко переключаться между задачами, а также наращивать мультипроцессорную систему.

Понятное дело, это потребует гигантского количества циклов.
Опытные схемы в Logisim и модели в Verilog почти работали. Счётчик машинных циклов задавал от двух до десяти циклов, что занимало от 6 до 30 тактов на одну атомарную инструкцию.
82404
Нейросеть заявляет, что пдобных архитектур в чистом виде не знает, хотя чем-то похоже на SPARC.

P.S.: Нейросеть рекомендует инструкцию HLT переименовать в BRK, что отсылает уже к прототипу 2019 года, когда я мнемонически думал назвать код 00 вообще END.
Но, всё это - косметика, так как не меняет ни сути, ни логики. Лишь облегчает визуальное ассоциативное восприятие.

[Alikberov]

Перепроектировал схему дешифратора команд.
Минимум вентилей - не более трёх на цепочку "бинарный код - операция".
82408
Здесь сигнал HLT_OP отсутствует и предполагает обработку через PTR_OP, так как разбор префиксов - довольно сложное дело и можно переложить HLT/BRK на него как частный случай.