Возможные микроархитектуры для 3niti alpha/beta

[Shaos]

... Простые микропрграммы копирующие из регистра в регистр (A,B,L,M,H) должны умещаться в одну микроинструкцию и заканчиваться раньше т.к. вычитка четвёртого байта из памяти микропрограмм будет ненужна - т.е. будет что-то типа такого:

1. прочитать триаду с шины данных (нужный PC к этому моменту уже должен быть подключен к шине адреса) и защёлкнуть её в регистре T0;
2. сформировать адрес микропрограммы (в общем случае это O|T0) и защёлкнуть первый байт микроинструкции в регистре I0;
3. подключить регистр источник и регистр приёмник к внутренней шине данных и защёлкнуть второй байт микроинструкции в регистре I1;
4. осуществить строб записи для сохранения необходимых данных и если надо флагов, а также обновить PC (в общем случае инкрементировать) и защёлкнуть третий байт микроинструкции в регистре I2, сохранив при этом способ перескока для следующего цикла;
5. опционально защёлкнуть четвёртый байт микроинструкции в регистре I3, если способ перескока этого требует (иначе этот шаг может быть пропущен).

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

Я тут вот чего подумал - ничего не мешает нам перехлестнуть этот опциональный пятый шаг на начало следующего цикла! Эдакий недо-конвейер получится, когда пятый шаг предыдущего цикла и первый шаг нового цикла будут выполняться одновременно, и все микроинструкции станут кратны 4 тактам!

Итак, получается, что почти все однотриадные инструкции (копирование между регистрами и сдвиги RLA и RRA) занимают одну микроинструкцию, которая выполняется всё также за 4 такта, а вот ADD похоже уходит в 8 тактов (там по ходу надо будет скопировать B в T1 т.к. сумматор всегда складывает A и T1)

2-триадные инструкции:
LAI # - загрузка регистра A следующей триадой - 8 тактов (2 микроинструкции)
ADI # - сложение A со следующей триадой - 12 тактов (3 микроинструкции)
OPA # - унарная троичная операция - 12 тактов (3 микроинструкции)

4-триадные инструкции:
LDI ### - загрузка текущего DP cледующими тремя триадами - 20 тактов (5 микроинструкций)
OPB ### - бинарная троичная операция - 20 тактов (5 микроинструкций)
JMP ### (обычный джамп на положительный адрес) - 20 тактов или больше (больше может потребоваться если исполняется инструкция из системы команд 3niti beta)

[Shaos]

Началь кодить turandot.cpp

Code: Select all

/*  Turandot - micoprogram engine that implements 3niti beta instruction set.

    Copyright (C) 2024 TERNARY RESEARCH CORPORATION <3niti@ternary.info>

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// I0 - bits 7 and 6 (DIRECT)

#define DIRECT_FROM_REG_TO_BUS_OR_REG "00"
#define DIRECT_FROM_BUS_TO_REG        "01"
#define DIRECT_FROM_REG_TO_MEM        "10"
#define DIRECT_FROM_MEM_TO_REG        "11"

// I0 - bits 5 and 4 (DSTMUX)

#define DSTMUX_BUS                    "00"

#define DSTMUX_REG_T0                 "00"
#define DSTMUX_REG_F                  "01"
#define DSTMUX_REG_A                  "10"
#define DSTMUX_REG_B                  "11"

#define DSTMUX_MEM_CHAN0              "00"
#define DSTMUX_MEM_CHAN1              "01"
#define DSTMUX_MEM_CHAN2              "10"
#define DSTMUX_MEM_SPECIAL            "11"

// I0 - bits 3 and 2 (SRCMUX)

#define SRCMUX_BUS                    "00"
#define SRCMUX_BUS_SLICE1             "01"
#define SRCMUX_BUS_SLICE2             "10"
#define SRCMUX_BUS_INPUT_PORT         "11"

#define SRCMUX_REG_T0                 "00"
#define SRCMUX_REG_F                  "01"
#define SRCMUX_REG_A                  "10"
#define SRCMUX_REG_B                  "11"

#define SRCMUX_MEM_CHAN0              "00"
#define SRCMUX_MEM_CHAN1              "01"
#define SRCMUX_MEM_CHAN2              "10"
#define SRCMUX_MEM_OPERATIONS         "11"

// I0 - bits 1 and 0 (MEMADR)

#define MEMADR_DPX_BY_INST            "00"
#define MEMADR_DPX_BY_FLAG            "01"
#define MEMADR_BY_SP                  "10"
#define MEMADR_TP                     "11"

#define MEMADR_OPERATION_OPA          "00"
#define MEMADR_OPERATION_OPB          "01"
#define MEMADR_OPERATION_ADD          "10"
#define MEMADR_OPERATION_SHIFTS       "11"

// I0 - SPECIAL bits 3..0 (INSTEAD OF SRCMUX & MEMADR)

#define SPECIAL_NOTHING             "0000"
#define SPECIAL_PC_TO_DP            "0001"
#define SPECIAL_PC_BY_SP            "0010"
#define SPECIAL_KEEP_PC_IF_TP_NEG   "0011"
#define SPECIAL_CONSTANT_OOO_TO_T1  "0100"
#define SPECIAL_CONSTANT_OOP_TO_T1  "0101"
#define SPECIAL_CONSTANT_OON_TO_T1  "0110"
#define SPECIAL_CONSTANT_PON_TO_T1  "0111"
#define SPECIAL_CONSTANT_NNO_TO_T1  "1000"
#define SPECIAL_CONSTANT_NNP_TO_T1  "1001"
#define SPECIAL_CONSTANT_NNN_TO_T1  "1010"
#define SPECIAL_CONSTANT_PPP_TO_T1  "1011"
#define SPECIAL_CONSTANT_ONO_TO_T1  "1100"
#define SPECIAL_CONSTANT_ONP_TO_T1  "1101"
#define SPECIAL_CONSTANT_ONN_TO_T1  "1110"
#define SPECIAL_CONSTANT_PNN_TO_T1  "1111"

// I1 - bits 7 and 6 (FLAGS OPERATION)

#define FLAGS_STAY_THE_SAME          "00"
#define FLAGS_UPDATE_BCF_ONLY        "01"
#define FLAGS_UPDATE_RSF_ONLY        "10"
#define FLAGS_UPDATE_BCF_AND_RSF     "11"

// I1 - bits 5 and 4 (SP OPERATION)

#define SP_INVALID                   "00" /* never ever use this */
#define SP_INCREMENT                 "01"
#define SP_DECREMENT                 "10"
#define SP_STAYS_THE_SAME            "11"

// I1 - bits 3..1 (PC OPERATION)

#define PC_STAYS_THE_SAME            "000"
#define PC_INCREMENT                 "001"
#define PC_IS_TP_NOW                 "010"
#define PC_IS_INVERTED_TP_NOW        "011"
#define PC_IS_RESTORED_FROM_SP       "100"
#define PC_IS_CURRENT_DP             "101"
#define PC_INTERRUPT                 "110"
#define PC_ERROR                     "111"

// I1 - bit 0 (AUXILARY OPERATION)

#define AUX_ZERO                     "0"
#define AUX_ONE                      "1"

// I2 - bits 7 and 6 (JUMP LOGIC)

#define JUMPLOGIC_NORMAL             "00"
#define JUMPLOGIC_SPECIAL            "01"
#define JUMPLOGIC_COMPLEX            "10"
#define JUMPLOGIC_IMMEDIATE          "11"

// I3 - bits 7..0 (JUMP ADDRESS)

#define N "10"
#define O "00"
#define P "01"
#define U "11"

#define UCODE_SIZE 256 /* must be power of 2 */

class Turandot
{
  char stemp[9];
  char* uCode[UCODE_SIZE];
 public:
  Turandot();
 ~Turandot();
  void error(int i=-1){printf("\n\nERROR%i\n\n",i);exit(i);}
  int set(const char* addr, const char* uinst, const char* jump=NULL);
  char* nextfree(int a=0);
};

Turandot::Turandot()
{
  for(int i=0;i<UCODE_SIZE;i++) uCode[i]=NULL;
}

Turandot::~Turandot()
{
  for(int i=0;i<UCODE_SIZE;i++) if(uCode[i]) delete uCode[i];
}

int Turandot::set(const char* addr, const char* uinst, const char* jump)
{
  if(addr==NULL || uinst==NULL) error(-2);
  int a = (int)strtol(addr,NULL,2);
  if(uCode[a]) error(-3);
  uCode[a]=new char[33];
  if(uCode[a]==NULL) error(-4);
  strcpy(uCode[a],uinst);
  while(strlen(uCode[a])<24) strcat(uCode[a],"1");
  if(jump!=NULL)
  {
     if(strlen(jump)!=8) error(-5);
     strcat(uCode[a],jump);
  }
  else strcat(uCode[a],"XXXXXXXX");
#ifdef DEBUG
  printf("set(%s,%s,%s) -> [%i]=%s\n",addr,uinst,jump?jump:"NULL",a,uCode[a]);
#endif
  return a;
}

char* Turandot::nextfree(int a)
{
#ifdef DEBUG
  int aa = a;
#endif
  while(++a < UCODE_SIZE)
  {
    if(uCode[a]==NULL)
    {
       int m = UCODE_SIZE/2;
       if(a<m)
       {
          if((a & 0x03) != 0x03 &&
             (a & 0x0C) != 0x0C &&
             (a & 0x30) != 0x30) continue;
       }
       stemp[0] = 0;
       int i = 0;
       while(m!=0)
       {
          if(a >= m)
          {
             strcat(stemp,"1");
             a -= m;
          }
          else strcat(stemp,"0");
          m /= 2;
       }
#ifdef DEBUG
       printf("nextfree(%i) -> %s\n",aa,stemp);
#endif
       return stemp;
    }
  }
  return NULL;
}

P.S. В байте I1 остался свободным 1 бит микрокода - bit 0 (AUXILARY OPERATION). Его пока можно просто на светодиод отправить, а в будущем, например можно опционально подключать T4 вместо T3 и/или T0' вместо T0 для реализации 6-тритных систем с 12-тритным адресом...

[Shaos]

Внутри функции main можно начать "кодить" микропрограммы:

Code: Select all

int main(int argc, char** argv)
{
 Turandot uc;
 // NNN (-13) SAN - Save value from register A to register N (memory cell with address DPn)
 uc.set( O N N N, DIRECT_FROM_REG_TO_BUS_OR_REG DSTMUX_BUS SRCMUX_REG_A MEMADR_DPX_BY_INST FLAGS_STAY_THE_SAME SP_STAYS_THE_SAME PC_INCREMENT AUX_ZERO JUMPLOGIC_NORMAL);
 // NNO (-12) SAO - Save value from register A to register O (memory cell with address DPo)
 uc.set( O N N O, DIRECT_FROM_REG_TO_BUS_OR_REG DSTMUX_BUS SRCMUX_REG_A MEMADR_DPX_BY_INST FLAGS_STAY_THE_SAME SP_STAYS_THE_SAME PC_INCREMENT AUX_ZERO JUMPLOGIC_NORMAL);
 // NNP (-11) SAP - Save value from register A to register P (memory cell with address DPp)
 uc.set( O N N P, DIRECT_FROM_REG_TO_BUS_OR_REG DSTMUX_BUS SRCMUX_REG_A MEMADR_DPX_BY_INST FLAGS_STAY_THE_SAME SP_STAYS_THE_SAME PC_INCREMENT AUX_ZERO JUMPLOGIC_NORMAL);
 // ...
 return 0;
}

Вот это всё превращается вот в такие последовательности нулей и единиц (вывод с включённым DEBUG):

Code: Select all

set(00101010,000010000011001000,NULL) -> [42]=000010000011001000111111XXXXXXXX
set(00101000,000010000011001000,NULL) -> [40]=000010000011001000111111XXXXXXXX
set(00101001,000010000011001000,NULL) -> [41]=000010000011001000111111XXXXXXXX

Код микроинструкции один и тот же т.к. в данном случае адресация микросхем памяти происходит по младшему триту кода инструкции (т.е. N,O или P) из-за директивы MEMADR_DPX_BY_INST - теперь надо просто продолжать в том же духе...

[Shaos]

Вобщем метод set добавляет микроинструкцию в память микропрограмм по адресу, который может быть указан либо как строка с ноликами и единичками, либо как последовательность троичных макросов N O P (которые внутри также являются строками из нулей и единичек "10", "00" и "01" соответственно) - это первый аргумент метода. Вторым аргументом метода set является непосредственно сама микроинструкция (без последнего байта с адресом перескока) в виде строки состоящей из ноликов и единичек - строка заводится последовательностями строковых макросов - если строка вышла короче 24 символов, то она добивается единичками. Необязательным третьим аргументом метода set является адрес перескока, задаваемый строкой из единичек и нулей. Возвращает метод set целочисленное значение адреса, которе затем может быть использовано для поиска следующей свободной ячейки для продолжения микропрограммы (если нужно) - для этого есть метод nextfree, который возвращает адрес следующей свободной ячейки опять же как строку единичек и нулей, которую можно использовать в качестве первого (обязательного) или третьего (необязательного) аргумента метода set. Надо ещё добавить метод modjump, который будет модифицировать адрес перескока у уже заведённой микроинструкции (т.к. в некоторых случаях на момент добавления микроинструкции мы можем не знать где она находится и соответственно нет информации куда надо перескакивать после её выполнения - обычно на следующую микроинструкцию или куда-то неподалёку). Также надо добавить методы save для сохранения бинарной прошивки для РФ2 (точнее половинки РФ2 т.к. размер прошивки будет 1024 байта) и print для распечатки микрокода в человеческом виде...

P.S. Внутри этого программного "эмулятора" я хочу оставаться в двоичной парадигме - в этом случае это должно будет достаточно легко портироваться на VHDL или Verilog для переноса на FPGA, а вот в "железной" реализации доля честной троичности планируется быть достаточно высокой - например счётчик PC будет полностью троичный, также всё мультиплексирование/демультиплексирование будет осуществляться аналоговыми селекторами, которые будут переключать троичные сигналы

[Shaos]

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

Метод modjump:

Code: Select all

void Turandot::modjump(int a, const char* jump)
{
  if(jump==NULL) error(-10);
  if(strlen(jump)!=8) error(-11);
  if(a<0 || a>=UCODE_SIZE) error(-12);
  if(!uCode[a]) error(-13);
  strcpy(&uCode[a][24],jump);
#ifdef DEBUG
  printf("modjump(%i,%s) -> [%i]=%s\n",a,jump,a,uCode[a]);
#endif
}

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

Code: Select all

void Turandot::fillblanks(const char* uinst)
{
  if(uinst==NULL) error(-20);
  if(strlen(uinst)>32) error(-21);
  for(int a=0;a<UCODE_SIZE;a++)
  {
    if(!uCode[a])
    {
       uCode[a] = new char[33];
       if(uCode[a]==NULL) error(-22);
       strcpy(uCode[a],uinst);
       while(strlen(uCode[a])<32) strcat(uCode[a],"1");
    }
  }
}

[Shaos]

Также надо добавить методы save для сохранения бинарной прошивки для РФ2 (точнее половинки РФ2 т.к. размер прошивки будет 1024 байта) и print для распечатки микрокода в человеческом виде...

Собственно вот:

Code: Select all

void Turandot::print(void)
{
  for(int a=0;a<UCODE_SIZE;a++)
  {
     if(uCode[a])
     {
        printf("[0x%2.2X] =",a);
        strncpy(stemp,uCode[a],8);
        stemp[8] = 0;
        printf(" %s",stemp);
        strncpy(stemp,&uCode[a][8],8);
        stemp[8] = 0;
        printf(" %s",stemp);
        strncpy(stemp,&uCode[a][16],8);
        stemp[8] = 0;
        printf(" %s",stemp);
        strncpy(stemp,&uCode[a][24],8);
        stemp[8] = 0;
        printf(" %s\n",stemp);
     }
  }
}

int Turandot::save(const char* filename)
{
  FILE *f = fopen(filename,"wb");
  if(f==NULL) return 0;
  for(int a=0;a<UCODE_SIZE;a++)
  {
     if(uCode[a])
     {
       for(int i=0;i<32;i+=8)
       {
          int b = 0;
          int j = 0;
          int m = UCODE_SIZE/2;
          while(m!=0)
          {
             if(uCode[a][i+j]!='0')
                b += m; // for '1' and 'X'
             m /= 2;
             j++;
          }
          fputc(b,f);
       }
     }
     else
     {
       fputc(0xFF,f);
       fputc(0xFF,f);
       fputc(0xFF,f);
       fputc(0xFF,f);
     }
  }
  fclose(f);
  return 1;
}

[Shaos]

У нас могут быть как минимум 4 варианта перехода на следующую микроинструкцию:

• 00 - нормальный по адресу O|T0 (обычный переход на новую микропрограмму в соответствии с кодом базовой инструкции 3niti);
• 01 - особый по адресу P|T1 если старший трит T1 равен N (для реализации новых инструкций 3niti beta кодируемых как JMP Nxx), в противном случае переход должен осуществляться по непосредственному адресу из четвёртого байта микроинструкции;
  ...

Придумал как сделать "особый" способ перескока в микропрограмме более универсальным - проверять старший трит регистра T1 на N (и перескакивать на P|T1) только если это была микроинструкция T0->T1!

Если же это была микроинструкция T0->T2, то проверять надо старший трит регистра T2 на равенство O (и перескакивать на P|T2 если так) - это чтобы отлавливать новые пользовательские инструкции типа JMP NPP Oxx (9 возможных инструкций, причём у них даже могут быть аргументы).

Во всех остальных случаях (включая T0->T3) надо проверять старший трит регистра T3 на равенство P (и перескакивать на P|T3) - это поможет отлавливать пользовательские инструкции типа JMP NPP yyy Pxx (если нужно - это ещё 9 инструкций у которых могут быть разные префиксы) т.е. это даст как минимум 9x9=81 новых инструкций, а также позволит реализовывать произвольное условное ветвление в сложных микропрограммах.

Перескок во всех этих случаях на адрес P|Tn позволит покрыть области 0100xxxx, 0101xxxx и 0110xxxx памяти микропрограмм (т.к. каждый раз мы проверяем на разное значение старшего трита - P,O,N), в то время как 00xxxxxx у нас отдано под старый набор команд (обычный перескок на O|T0), а зона 1xxxxxxx (вторая половина памяти) свободна для сложных микропрограмм пользователя т.к. произвольный переход по обычному способу может быть произведён на любой двоичный адрес в пределах памяти микропрограмм...

P.S. На самом деле под это дело можно просто больше битов отводить в I2 вплоть до указания того, с каким значением мы сравниваем старший трит - с N,O,P или их комбинацией (например переходить на адрес P|T3 если старший трит регистра T3 равен P или O иначе идти на адрес из I3).

Пожалуй надо отвязаться от кода микроинструкции и просто брать старший трит регистра T0, управляя логикой из дополнительных битов I2 (наряду с битами перескока):

0100 - если страший трит T0 равен O, то переход на P|T0
0101 - если страший трит T0 равен P, то переход на P|T0
0110 - если страший трит T0 равен N или P (?), то переход на P|T0
0111 - если страший трит T0 равен N, то переход на P|T0 (по умолчанию)

Это будет работать только для перескока 01 - особый (старшие 2 бита из I2) и т.к. переход будет уже в следующем цикле в начале которого T0 будет перечитан, то на этапе анализа надо будет сохранить значение T0 - назовём его T0*. Получается перескок может осуществляться только на один из трёх адресов:

• O|T0 (новый T0) для кода перескока 00 всегда и для кода перескока 10 когда условие не выполняется (TP>=0)
• P|T0* (старый T0) для кода перескока 01 когда условие выполняется (старший трит T0 равен указанным значениям)
• I3 для кода перескока 11 всегда, для кода перескока 01 когда условие не выполняется и для кода перескока 10 когда условие выполняется (TP<0)

P.S. Последние 2 случая можно объединить, подменяя адрес перескока I3 на P|T0, если условие выполняется! Тогда не придётся мудрить с запоминанием старого значения T0 (точнее оно будет запомнено регистром I3 вместо значения, которое было в ПЗУ для данной микроинструкции) - выходит оно будет просто переходить на I3 всегда и при 11, и при 01 (а при 10 только если условие TP<0 выполняется - как раз вот это придётся запомнить на триггере...

[Shaos]

В байте I1 остался свободным 1 бит микрокода - bit 0 (AUXILARY OPERATION). Его пока можно просто на светодиод отправить, а в будущем, например можно опционально подключать T4 вместо T3 и/или T0' вместо T0 для реализации 6-тритных систем с 12-тритным адресом...

Можно поразмышлять на тему как с таким подходом поддержать ту же Тунгуску:

Screenshot from 2024-06-21 00-20-50.png

Свободные 4 бита в I2 могут быть использованы для переключения страниц в памяти микропрограмм (которую можно нарастить таким образом аж до 16КБ). Как можно видеть выше формат инструкции Тунгуски AAC CCC, где старшие 2 трита задают способ адресации, а следующие 4 - непосредственно саму операцию. При чтении кода инструкции из памяти в T0 попадёт старшая триада, а в T0' - младшая. Можно сразу же отправиться на выполнение кода адресации по адресу O|T0 (страница 0000). Далее надо будет запомнить T0' где-то и младший трит из T0. Отработав способ адресации защёлкиваем аргумент куда-то и идём на выполнение операции которую запомнили, перещёлкивая страницу памяти микропрограмм. Вобщем как-то так...

[Shaos]

Тут люди реверснули микрокода Пентиума:

https://www.righto.com/2025/03/pentium-microcde-rom-circuitry.html

и насчитали там 414720 бит в памяти микрокода, которая содержит 4608 микроинструкции или 90 бит на инструкцию...

[aviator]

О, это же не кто-то, а сам Мастер Кен с канала "Любопытный Марк". Кстати, они ж находятся где-то рядом с вами, в Кремниевой Долине.