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

[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, если индекс Приёмника не меняется.
Пустячок, правда? Однако, нейросеть жалуется на то, что ни в одной из знакомых ей архитектур действие атомарных инструкций не может распространяться на сотни последующих. Из-за чего она в стратегическом планировании кода путается.
И это - малая доля сложностей.
Ещё нейронка говорит, что самому человеку в уме легко держать текущий контекст, так как интуитивнно это очевидно. А нейросети приходится постоянно пересматривать код.

[Advertiser]