Цифровая археология: 1801 и все-все-все

[Vslav]

Хочу подключить ВМ2 к ПЛИС. Согласно документации выходное напряжение высокого уровня ВМ2 - 2,4В. Правильно ли я понимаю, что шифтеры не нужны? Или же нужны, но для того, чтобы 2,4В приводить к 3,3В?

2.4В - это минимальное выходное напряжение высокого уровня. А реально может быть и до напряжения питания, то есть до +5В. Если делать совсем правильно, то смотрите схему подключения ВМ2 к ПЛИС тут:
Экспериментальные модули
CAD файлы на github

[Advertiser]

[AlexG]

А почему к примеру не использовались "преобразователи уровня" ?
http://www.gaw.ru/html.cgi/txt/ic/Te...vels/start.htm

[Vslav]

А почему к примеру не использовались "преобразователи уровня" ?

Да чего в шкафчике было, то и использовал - LVC245. Свою задачу решает, дешево и легко доставаемо.
Вот для 581 преобразователи понадобились, пришлось покупать.

[Sergey]

Да чего в шкафчике было, то и использовал - LVC245. Свою задачу решает, дешево и легко доставаемо.

А использование CPLD, толерантной к 5В, недостаточно? - я смотрю, сопряжение 3в с 5в в современных амижных акселераторах делается только за счёт XC95nnXL CPLD.

[Vslav]

А использование CPLD, толерантной к 5В, недостаточно? - я смотрю, сопряжение 3в с 5в в современных амижных акселераторах делается только за счёт XC95nnXL CPLD.

Прошу прощения, я не очень понял вопрос. На плате модулей 1801ВМx установлена MAX3064 - это как раз 5V-толерантная CPLD и два и более 74LVC245. LVC245 установлены для шины данных, если делать им замену на от CPLD это потребовало бы 32 входа/выхода - надо было бы ставить или заметно более толстую MAX3256 в корпусе TQFP-144 или две CPLD и еще возиться с программированием второй. Сильно жирно для простого преобразования уровня на шине данных.

[Hunta]

Vslav, а что скажешь на предмет вскрытия FPA?

[Vslav]

Vslav, а что скажешь на предмет вскрытия FPA?

Ничего не скажу, мне ВМ3 и F11 вполне хватит для реверса

[Vslav]

Алгоритм исполнения, выясненный методом научного тыка:

R0:=0;
         while ((R0[7]==0) && (R2[7]==0))
          {
 R1:=R1<<1 | 0; R2[07:00]:=R2[07:00]<<1 | C;
 R2[15:08]:=R2[7]; R3:=R3<<1 | C; R0++;
          }
         N:=0; Z:=(R0==0); V:=0; C:=0

Я написал такой обработчик HALT (вектор 70₈):

hmode:		mov	#50, R0			;
		mov	#10, R1			;
		mov	#12, R2			;
		mov	#23, R3			;
		mov	#34, R4			;
		mov	#45, R5			;
		.word	30			;
		mov	R0, R1			;
		br	hmode			;

Результат листинга микрокода:

# plm[42->37]  op1  word  fw ac  ****   QREG   vector  000170   x+y  ---  rdat 001732 001732 001734 ir:000000 4 6 42 // формируем адрес вектора для чтения
# plm[37->02]  op2  word     *x  ****    R7     QREG   ------     y  ---  ---- 001732 001732 001734 ir:000000 4 6 37  // прочитали новое значение PC из вектора
# plm[02->31]  op1  word  fw ac  ****    ACC   000002  ------   x+y  ---  rdat 001732 001150 001150 ir:000000 4 6 02  // обновили адрес для чтения +2
# plm[31->06]  op2  word     *x  ****    PSW    QREG   ------     y  ---  ---- 001732 001150 001150 ir:000000 4 6 31  // прочитали новое PSW из вектора
# Access to halt vector  // отладочный останов
# Break in Module tb2 at E:/GIT/cpu11/vm2/hdl/org/tbe/de0_tb2.v line 143
# run
# plm[06->32]  se0  byte    n/a  ----     n/a     n/a  ------   n/a  n/a   n/a 001732 001150 001150 ir:000000 4 6 06
# plm[32->36]  op2  word     *x  ****    ACC     ACC   ------     y  ---  ---- 001732 001150 001150 ir:000000 4 0 32
# plm[36->76]  op1  word  fr *x  ****    R7    000002  ------   x+y  ---  rcmd 001732 001150 001150 ir:000000 4 1 36  // выборка инструкции
# plm[76->77]  op1  word  f2 *x  nzv-    R7    000002  ------   x+y  ---  pref 001732 001152 001152 ir:000000 4 1 76  // предвыборка следующей инструкции
# plm[77->55]  op2  word     ac  ****    R7      R2    ------     x  ---  ---- 001732 001154 001154 ir:012700 7 6 60
# plm[55->57]  op2  word     *x  ****   R_SRC   QREG   ------     y  ---  ---- 001732 001154 001154 ir:012700 4 6 55  // чтение литерала #50
# plm[57->54]  op1  word  f2 *x  ****    R7    000002  ------   x+y  ---  pref 001732 001154 001154 ir:012700 4 6 57  // предвыборка следующей инструкции
# plm[54->76]  op2  byte     *x  wsta    R0     R_SRC  ------     y  ---  ---- 001732 001154 001156 ir:012700 4 6 54  //  R0 = 50
# plm[76->77]  op1  word  f2 *x  nzv-    R7    000002  ------   x+y  ---  pref 001732 001154 001156 ir:012700 4 1 76 // предвыборка следующей инструкции
# plm[77->55]  op2  word     ac  ****    R7      R2    ------     x  ---  ---- 001732 001160 001160 ir:012701 7 6 60
# plm[55->57]  op2  word     *x  ****   R_SRC   QREG   ------     y  ---  ---- 001732 001160 001160 ir:012701 4 6 55
# plm[57->54]  op1  word  f2 *x  ****    R7    000002  ------   x+y  ---  pref 001732 001160 001160 ir:012701 4 6 57
# plm[54->76]  op2  byte     *x  wsta    R1     R_SRC  ------     y  ---  ---- 001732 001160 001162 ir:012701 4 6 54  // R1 = 10
# plm[76->77]  op1  word  f2 *x  nzv-    R7    000002  ------   x+y  ---  pref 001732 001160 001162 ir:012701 4 1 76
# plm[77->55]  op2  word     ac  ****    R7      R2    ------     x  ---  ---- 001732 001164 001164 ir:012702 7 6 60
# plm[55->57]  op2  word     *x  ****   R_SRC   QREG   ------     y  ---  ---- 001732 001164 001164 ir:012702 4 6 55
# plm[57->54]  op1  word  f2 *x  ****    R7    000002  ------   x+y  ---  pref 001732 001164 001164 ir:012702 4 6 57
# plm[54->76]  op2  byte     *x  wsta    R2     R_SRC  ------     y  ---  ---- 001732 001164 001166 ir:012702 4 6 54  // R2 = 12
# plm[76->77]  op1  word  f2 *x  nzv-    R7    000002  ------   x+y  ---  pref 001732 001164 001166 ir:012702 4 1 76
# plm[77->55]  op2  word     ac  ****    R7      R2    ------     x  ---  ---- 001732 001170 001170 ir:012703 7 6 60
# plm[55->57]  op2  word     *x  ****   R_SRC   QREG   ------     y  ---  ---- 001732 001170 001170 ir:012703 4 6 55
# plm[57->54]  op1  word  f2 *x  ****    R7    000002  ------   x+y  ---  pref 001732 001170 001170 ir:012703 4 6 57
# plm[54->76]  op2  byte     *x  wsta    R3     R_SRC  ------     y  ---  ---- 001732 001170 001172 ir:012703 4 6 54  // R3 = 23
# plm[76->77]  op1  word  f2 *x  nzv-    R7    000002  ------   x+y  ---  pref 001732 001170 001172 ir:012703 4 1 76
# plm[77->55]  op2  word     ac  ****    R7      R2    ------     x  ---  ---- 001732 001174 001174 ir:012704 7 6 60
# plm[55->57]  op2  word     *x  ****   R_SRC   QREG   ------     y  ---  ---- 001732 001174 001174 ir:012704 4 6 55
# plm[57->54]  op1  word  f2 *x  ****    R7    000002  ------   x+y  ---  pref 001732 001174 001174 ir:012704 4 6 57
# plm[54->76]  op2  byte     *x  wsta    R4     R_SRC  ------     y  ---  ---- 001732 001174 001176 ir:012704 4 6 54  // R4 = 34
# plm[76->77]  op1  word  f2 *x  nzv-    R7    000002  ------   x+y  ---  pref 001732 001174 001176 ir:012704 4 1 76
# plm[77->55]  op2  word     ac  ****    R7      R2    ------     x  ---  ---- 001732 001200 001200 ir:012705 7 6 60
# plm[55->57]  op2  word     *x  ****   R_SRC   QREG   ------     y  ---  ---- 001732 001200 001200 ir:012705 4 6 55
# plm[57->54]  op1  word  f2 *x  ****    R7    000002  ------   x+y  ---  pref 001732 001200 001200 ir:012705 4 6 57
# plm[54->76]  op2  byte     *x  wsta    R5     R_SRC  ------     y  ---  ---- 001732 001200 001202 ir:012705 4 6 54  // R5 = 45, PC=1202
# plm[76->77]  op1  word  f2 *x  nzv-    R7    000002  ------   x+y  ---  pref 001732 001200 001202 ir:012705 4 1 76  // предвыборка инструкции следующей за 030

// здесь начитается обработка инструкции 030 в HALT-режиме
# plm[77->30]  op1  word     *x  ****    R0    000000  ------     y  ---  ---- 001732 001202 001204 ir:000030 5 2 72  // mov #0, R0 ; R0 is 000000
# plm[30->12]  op2  byte     ac  nzv-    R2      R0    ------     x  ---  ---- 001732 001202 001204 ir:000030 4 2 30  // проверка условий выхода из цикла??
# plm[12->16]  op1  byte     *x  nzv-    R0    000001  ------   x+y  ---  ---- 001732 001202 001204 ir:000030 6 2 12  // incb R0 ; R0 is 000001
# plm[16->46]  op2  word     *y  ****    R0      R1    ------     y  asl  ---- 001732 001202 001204 ir:000030 6 2 16  // asl R1 ; R1 is 20 
# plm[46->41]  op2  word     *y  ****    R0      R3    ------     y  rol  ---- 001732 001202 001204 ir:000030 4 2 46  // rol R3 ; R3 is 46
# plm[41->12]  op2  byte     *y  nzv-    R0      R2    ------     y  rol  ---- 001732 001202 001204 ir:000030 4 2 41  // rolb R2 ; R2 is 24
# plm[12->16]  op1  byte     *x  nzv-    R0    000001  ------   x+y  ---  ---- 001732 001202 001204 ir:000030 6 2 12  // incb R0 ; R0 is 000002
# plm[16->46]  op2  word     *y  ****    R0      R1    ------     y  asl  ---- 001732 001202 001204 ir:000030 6 2 16  // asl R1 ; R1 is 40  
# plm[46->41]  op2  word     *y  ****    R0      R3    ------     y  rol  ---- 001732 001202 001204 ir:000030 4 2 46  // rol R3 ; R3 is 114
# plm[41->12]  op2  byte     *y  nzv-    R0      R2    ------     y  rol  ---- 001732 001202 001204 ir:000030 4 2 41  // rolb R2 ; R2 is 50
# plm[12->16]  op1  byte     *x  nzv-    R0    000001  ------   x+y  ---  ---- 001732 001202 001204 ir:000030 6 2 12  // incb R0 ; R0 is 000003
# plm[16->46]  op2  word     *y  ****    R0      R1    ------     y  asl  ---- 001732 001202 001204 ir:000030 6 2 16  // asl R1 ; R1 is 100  
# plm[46->41]  op2  word     *y  ****    R0      R3    ------     y  rol  ---- 001732 001202 001204 ir:000030 4 2 46  // rol R3 ; R3 is 230
# plm[41->12]  op2  byte     *y  nzv-    R0      R2    ------     y  rol  ---- 001732 001202 001204 ir:000030 4 2 41  // rolb R2 ; R2 is 120
# plm[12->16]  op1  byte     *x  nzv-    R0    000001  ------   x+y  ---  ---- 001732 001202 001204 ir:000030 6 2 12  // incb R0 ; R0 is 000004
# plm[16->46]  op2  word     *y  ****    R0      R1    ------     y  asl  ---- 001732 001202 001204 ir:000030 6 2 16  // asl R1 ; R1 is 200  
# plm[46->41]  op2  word     *y  ****    R0      R3    ------     y  rol  ---- 001732 001202 001204 ir:000030 4 2 46  // rol R3 ; R3 is 460
# plm[41->12]  op2  byte     *y  nzv-    R0      R2    ------     y  rol  ---- 001732 001202 001204 ir:000030 4 2 41  // rolb R2 ; R2 is 177640
# plm[12->76]  op2  byte     ac  nzvc    R0      R0    ------     x  ---  ---- 001732 001202 001204 ir:000030 4 2 12  // цикл закончен, установка флагов
# plm[76->77]  op1  word  f2 *x  nzv-    R7    000002  ------   x+y  ---  pref 001732 001202 001204 ir:000030 4 1 76 // предвыборка инструкции br hmode
# plm[77->76]  op2  byte     *x  wsta    R1      R0    ------     y  ---  ---- 001732 001204 001206 ir:010001 5 2 04  //  исполнение mov R0, R1
# plm[76->77]  op1  word  f2 *x  nzv-    R7    000002  ------   x+y  ---  pref 001732 001204 001206 ir:010001 4 1 76  // предвыборка инструкции следующей за br hmod
# plm[77->36]  op1  word     *x  ****    R7    br_off  ------   x+y  ---  ---- 001732 001206 001210 ir:000761 7 2 73  // выполнение br

Cкроллим код вправо - там мои комментарии.
В-общем, похоже что порядок R2:R3 другой.
И еще - флаг С тут похоже не переносится, то есть это не цепочный сдвиг регистров. Я попробовад задать R1=210, и 200 не перехало в R3.

[Vslav]

1. Обновил документацию по ВМ1:
- исправил опечатки и поредактировал футеры, теперь формат документа стал оптимальнее
- теперь PDF умеет в оглавление и закладки, типа такого:

Скрытый текст

[свернуть]

2. Добавил утилиту для анализа матриц ПЛМ для 1801ВМ1А/Г и для ВМ2:
- умеет перебирать все микроадреса (полный диапазон или по параметрам из командной строки)
- умеет делать перебор микроадресов только для указанного PDP-11 опкода с маской
- функции могут использовать SSE2/AVX2 инструкции для ускорения
- функции умеют строить оптимальное М-арное дерево для оптимизации вычисления матриц
(правда дерево вырожденное - один корень с листьями )
- под win32/64, но возможно соберется под линуксом (у меня не было GCC старше 4.9, оно не умеет в __mi256i), Makefile в комплекте
(если будут желающие - попробуйте, я приму PR с обновлениями для Linux)
- лежит на github и тут
- старая версия (где 100500 закомментированных подветок для анализа частных случаев ВМ1А на основе которой писался и проверялся документ) - тут, это чисто рабочий вариант, не для публикации, просто показывает сколько всего было проанализировано, этой ветки в официальной репке не будет.
- на основе это утилиты для ВМ2 надо брать и добавлять анализ специальных случаев, как это было сделано для ВМ1 в старой ветке

Примечание для эмуляторщиков: код функций вычисления матриц может быть использован для эмуляции микрокода серии 1801, производительность примерно до 100M отсчетов в секунду на одном ядре 4770@3.4GHz. Функции могут быть использованы или прямо для вычисления выходя матриц в момент исполнения, или для заполнения ускоряющих таблиц.

[Vslav]

Программируемые логические матрицы

Микропроцессоры серии 1801, в-основном, построены вокруг одной большой программируемой логической матрицы - PLM. Эта матрица объединяет горизонтальный микрокод, управление состоянием конечного автомата и логику декодирования операций и может рассматриваться как набор простых комбинаторных функций входного логического вектора X, обеспечивающая выходной вектор Y:

y [m: 0] = f (x [n: 0])

Состояние конечного автомата определяется как адрес «микрокоманды», некоторое число младших битов входного вектора - это поле микроадреса, а выходной вектор содержит новое значение, которое будет присвоено микроадресному регистру - поле «следующий адрес». Следующие биты адреса могут быть "размазаны" по битам выходного вектора из-за того, что порядок битов определяется в процессе реверса, и не всегда очевидно, где находятся эти биты. Шестнадцать старших битов входного вектора всегда являются текущим кодом операции инструкции PDP-11.

Матрица включает логические функции в дизъюнктивной нормальной форме. Есть набор продуктов (p, логических произведений), сравниваемых с входным вектором с маскированием и совпавшие продукты объединяются в выходной вектор с помощью логического ИЛИ.

В таблице представлены параметры матриц для процессоров серии 1801:

1801BM1A - 31 бит на входе, 34 бита на выходе, 7 бит ширина микроадреса, 248 продуктов
1801BM1Г - 31 бит на входе, 34 бита на выходе, 7 бит ширина микроадреса, 249 продуктов
1801BM2 - 28 бит на входе, 37 бит на выходе, 6 бит ширина микроадреса, 198 продуктов

Матричные процедуры реализуют матричную функцию. Поддерживаемая ширина входного вектора ограничена 32 битами, а поддерживаемая ширина вывода ограничена 64 битами, прототип функции выглядит так:

uint64_t f (uint32_t x);

Основной алгоритм - проверить все продукты, выбрать те которые совпадают с данным значением входного вектора и добавить к выходному результату используя логическое ИЛИ:

for each product {
  if product matches input {
     add to result
  }
}

Возможны некоторые простые и сразу очевидные оптимизации. Маскированное сравнение продуктов с входным вектором - это просто логическое XOR и AND, можно использовать SIMD-инструкции для обработки нескольких векторов за одну операцию. SSE2 реализация обрабатывает четыре вектора на итерацию цикла, реализация AVX2 может обрабатывать восемь векторов за итерацию.

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

Например, мы выбрали четыре младших бита в качестве индекса группы, и построили (один раз во время инициализации) шестнадцать массивов продуктов сопоставленные с индексами группы 0..15. Входные векторы xxxx0 будут использовать продукты группы 0 для вычисления результата, векторы xxxx5 будут использовать группу 5 и так далее.

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

Приложение для анализа микрокода

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

Имеется эталонная матрица для 1801ВМ1А, реализованная в самый простой способ и проверенная с помощью моделирования Verilog в ходе документирования 1801ВМ1. Новые реализации матричных процедур включая SIMD и оптимизированные для дерева, можно напрямую сравнить с проверенной реализацией, эта функция включается ключом --match и предоставляется только для 1801BM1A.

Ключ --speed включает тесты измерения производительности, перебирается весь диапазон ввода (2^31 - 2млрд комбинаций для 1801ВМ1), вычисляется функция матрицы, и сообщается полученное время.

Метод --table строит таблицы микроадресов и собирает статистику о переходах на целевые микроадреса. Данный цикл следует дополнять кодом для сбора специальной статистики.