DEC и я

[Hunta]

Немного поигрался с подключением к PDP-11 через telnet. Вроде нормально работает.

Если кто хочет поиграться на моих разных PDP-11 (как оригинальных, так и на советских копиях) - вопрос решаемый
В списке операционок пока RT-11 (из тех, кто имеет драйвер DU) и RSX-11M-Plus 4.6

[Hunta]

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

Добавлена возможность оценки быстродействия не только команд из одного слова, но и блоков команд, оцениваемых как одно действия. Например, таким образом можно оценить, сколько раз за секунду выполнится блок:

	MOV #BUF1, R0
	MOV #BUF2, R1
	MOV #8, R2
1001$:
	MOV (R0)+, (R1)+
	SOB R2, 1001$

И насколько быстрее он выполнится, если его записать в виде

	MOV #BUF1, R0
	MOV #BUF2, R1
	MOV #4, R2
1001$:
	MOV (R0)+, (R1)+
	MOV (R0)+, (R1)+
	SOB R2, 1001$

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

Всё таки напортачил ещё в одном месте. Надо было делить, а я умножил. Так что старые результаты по CIS по прежнему не верны.
Новые данные (и вроде корректные )

.RUN SPEED3

Тест быстродействия

R1+R0            533 тыс. оп./сек
R1+@R0           332 тыс. оп./сек
R0*R0             41 тыс. оп./сек
R2/R0            130 тыс. оп./сек
CIS MULPI 1      0,5 тыс. оп./сек
CIS MULPI 2        2 тыс. оп./сек
CIS ADDNI 1     3,25 тыс. оп./сек
CIS ADDNI 2      6,5 тыс. оп./сек
MOV 8 word 1    7,75 тыс. оп./сек
MOV 8 word 2    9,22 тыс. оп./сек
.

[Hunta]

Ну, если не насажал опять ошибок, то вот как то так:

.RUN SPEED3

Тест быстродействия

R1+R0           532 554 оп./сек
R1+@R0          331 706 оп./сек
R0*R0            40 784 оп./сек
R2/R0           130 207 оп./сек
CIS MULPI 1         432 оп./сек
CIS MULPI 2       2 005 оп./сек
CIS ADDNI 1       3 145 оп./сек
CIS ADDNI 2       6 496 оп./сек
MOV 8 word 1      7 736 оп./сек
MOV 8 word 2      9 205 оп./сек
.

[Hunta]

После знакомства с принципом работы SPEED меня смущали две вещи.

Во-первых, способ работы с накладными расходами. В SPEED сделана попытка минимизировать их влияние за счёт того, что выполняется большое количество целевой команды (16000., если быть точнее). Типа, на фоне такого количества команд их (накладных расходов) влияние будет минимальным. Ну... В принципе - да, но хотелось бы ещё меньше Ещё минус - такой большой блок приводит к тому, что у программы повышенные требования к памяти - ей требуется память примерно до адреса 101400(8). Это стало проблемой, когда я попытался посчитать быстродействие синтезированного процессора с объёмом памяти (примерно, ЕМНИП) в 50000(8) байт. А ведь и RT ещё требует себе память

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

Всё это привело к тому, что был реализован (версия 0.1, типа - пока проверяется идея) вариант программы, когда для вычисления быстродействия команды в одинаковых условиях делается два действия - цикл со всеми нужными действиями, кроме, собственно, тестируемой команды и цикл вместе с командой. А потом расчёт (пока ручной, но... версия то 0.1 ) быстродействия команды без накладных расходов.

Что получилось (после ; - вычисленное быстродействие):

.RUN SPEED3

Тест быстродействия

R1+R0 classic                     532 243 оп./сек

R1(23456.)+R0(12345.) empty       165 677 оп./сек
R1(23456.)+R0(12345.)             126 583 оп./сек ; 536 448 оп./сек

R1+@R0 classic                    331 600 оп./сек

R1(23456.)+@R0(M-12345.) empty    165 679 оп./сек
R1(23456.)+@R0(M-12345.)          110 479 оп./сек ; 331 595 оп./сек

R0*R0 classic                      40 780 оп./сек

empty 11.*12.                     165 682 оп./сек
11.*12.                            32 669 оп./сек ; 40 693 оп./сек

R2/R0 classic                     141 058 оп./сек

R2-R3(34567.)/R1(321.) empty      126 577 оп./сек
R2-R3(34567.)/R1(321.)             20 121 оп./сек ; 23 924 оп./сек

CIS MULPI 1                           432 оп./сек

CIS MULP  1 empty                  57 071 оп./сек
CIS MULP  1                           458 оп./сек ; 462 оп./сек

CIS MULPI 2                         2 005 оп./сек

CIS MULP  2 empty                  57 087 оп./сек
CIS MULP  2                         2 409 оп./сек ; 2 515 оп./сек
...

[Hunta]

Для кода без тестируемой команды и кода с тестируемой командой создал более одинаковые условия. Новый результат:

.RUN SPEED3

Тест быстродействия

R1+R0 classic                     531 272 оп./сек

R1(23456.)+R0(12345.) empty       165 729 оп./сек
R1(23456.)+R0(12345.)             126 598 оп./сек ; 536 172

R1+@R0 classic                    331 022 оп./сек

R1(23456.)+@R0(M-12345.) empty    165 728 оп./сек
R1(23456.)+@R0(M-12345.)          110 531 оп./сек ; 331 867

R0*R0 classic                      40 764 оп./сек

empty 11.*12.                     165 722 оп./сек
11.*12.                            32 670 оп./сек ; 40 692

R2/R0 classic                     140 979 оп./сек

R2-R3(34567.)/R1(321.) empty      126 606 оп./сек
R2-R3(34567.)/R1(321.)             20 122 оп./сек ; 23 924

CIS MULPI 1                           432 оп./сек

CIS MULP  1 empty                  57 081 оп./сек
CIS MULP  1                           459 оп./сек ; 463

CIS MULPI 2                         2 005 оп./сек

CIS MULP  2 empty                  57 078 оп./сек
CIS MULP  2                         2 459 оп./сек ; 2 570

CIS ADDNI 1                         3 145 оп./сек
CIS ADDN  1                           518 оп./сек
CIS ADDNI 2                         6 496 оп./сек
CIS ADDN  2                         2 563 оп./сек
MOV 8 word 1                       14 503 оп./сек
MOV 8 word 2                       17 002 оп./сек
CIS MOV 8 word 1                   14 015 оп./сек

[Hunta]

Собрал таки свой стенд с ВМ3 обратно (я тут в выходные перестановки на рабочем столе устраивал) и...
Запустил SPEED3 на нем

Результаты в принципе ожидаемые
Первые три результаты немного получше (меньше не учитываемых накладных расходов).
А деление даёт более реалистичный результат (если я правильно прикинул в SPEED считается скорость расчёта выражения 0/1 )

.RUN ZF:SPEED3

Тест быстродействия

R1+R0 classic                   1 638 592 оп./сек

R1(23456.)+R0(12345.) empty       248 846 оп./сек
R1(23456.)+R0(12345.)             216 720 оп./сек ; 1 678 700 оп./сек

R1+@R0 classic                    414 136 оп./сек

R1(23456.)+@R0(M-12345.) empty    248 845 оп./сек
R1(23456.)+@R0(M-12345.)          155 851 оп./сек ; 417 046 оп./сек

R0*R0 classic                      83 174 оп./сек

empty 11.*12.                     248 845 оп./сек
11.*12.                            62 391 оп./сек ; 83 268 оп./сек

R2/R0 classic                     331 551 оп./сек

R2-R3(34567.)/R1(321.) empty      216 720 оп./сек
R2-R3(34567.)/R1(321.)             41 951 оп./сек ; 52 021 оп./сек

MOV 8 word 1                       13 680 оп./сек
MOV 8 word 2                       17 002 оп./сек
.

Ну и если сравнивать с F-11, ВМ3 получается немного побыстрее

[Advertiser]

[Hunta]

Дело было вечером, делать было нечего и...
Я вспомнил, что хотел плавучку вставить в тест.
Вспомнено, сделано.
Завтра на свежую голову посмотрю - не накосячил ли

.RUN SPEED3

Тест быстродействия

R1+R0 classic                     532 538 оп./сек

R1(23456.)+R0(12345.) empty       165 506 оп./сек
R1(23456.)+R0(12345.)             126 859 оп./сек ; 543274

R1+@R0 classic                    330 635 оп./сек

R1(23456.)+@R0(M-12345.) empty    165 547 оп./сек ; 331602
R1(23456.)+@R0(M-12345.)          110 421 оп./сек

R0*R0 classic                      40 776 оп./сек

empty 11.*12.                     165 587 оп./сек
11.*12.                            32 678 оп./сек ; 40712

R2/R0 classic                     140 873 оп./сек

R2-R3(34567.)/R1(321.) empty      126 727 оп./сек
R2-R3(34567.)/R1(321.)             20 129 оп./сек ; 23930

34567.89022+32109.754321 empty     33 435 оп./сек
34567.89022+32109.754321           12 084 оп./сек ; 18923  FPP!

CIS MULPI 1                           432 оп./сек

CIS MULP  1 empty                  56 912 оп./сек
CIS MULP  1                           454 оп./сек ; 458

CIS MULPI 2                         2 005 оп./сек

CIS MULP  2 empty                  56 956 оп./сек
CIS MULP  2                         2 316 оп./сек ; 2414

CIS ADDNI 1                         3 145 оп./сек
CIS ADDN  1                         1 598 оп./сек

CIS ADDNI 2                         6 496 оп./сек
CIS ADDN  2                         1 186 оп./сек

MOV 8 word 1                       14 505 оп./сек
MOV 8 word 2                       17 000 оп./сек

CIS MOV 8 word 1                   14 017 оп./сек

[Hunta]

Что бы не считать руками каждый раз, понадобились мне операции умножения и деления, которые работают с int32 и int64(частично).
Взял за основу DEC-овские $DMUL и $DDIV и допилил их. Ну понятно, с ходу не заработали (куда ж без косяков), но косяки были тривиальные (да да, в том числе от копи-паста), так поправил быстро. Новые результаты для F11 (есть ещё небольшой нюанс с усечением-округлением, но он влияет только на +1 оп/с, так что пока так ) Ну и добавил ещё тестов плавающей запятой Кстати, в предыдущем результате плавающего сложения - ошибка. Нашёл, когда воевал с плавающем делением

.RUN SPEED3

Тест быстродействия

R1+R0 classic                     530 627 оп./сек
R1(23456.)+R0(12345.) empty       165 248 оп./сек
R1(23456.)+R0(12345.)             126 800 оп./сек ->     544 981 оп./сек
R1+@R0 classic                    329 680 оп./сек
R1(23456.)+@R0(M-12345.) empty    165 274 оп./сек
R1(23456.)+@R0(M-12345.)          110 282 оп./сек ->     331 443 оп./сек
R0*R0 classic                      40 754 оп./сек
empty 11.*12.                     165 294 оп./сек
11.*12.                            32 679 оп./сек ->      40 731 оп./сек
R2/R0 classic                     140 817 оп./сек
R2-R3(34567.)/R1(321.) empty      126 725 оп./сек
R2-R3(34567.)/R1(321.)             20 123 оп./сек ->      23 921 оп./сек
34567.89022+32109.754321 empty     26 730 оп./сек
34567.89022+32109.754321            9 787 оп./сек ->      15 440 оп./сек
34567.89022*32109.754321 empty     26 728 оп./сек
34567.89022*32109.754321            3 595 оп./сек ->       4 153 оп./сек
34567.89022/32109.754321 empty     26 728 оп./сек
34567.89022/32109.754321            3 495 оп./сек ->       4 020 оп./сек
CIS MULPI 1                           433 оп./сек
CIS MULP  1 empty                  56 537 оп./сек
CIS MULP  1                           458 оп./сек ->         461 оп./сек
CIS MULPI 2                         2 006 оп./сек
CIS MULP  2 empty                  56 538 оп./сек
CIS MULP  2                         2 439 оп./сек ->       2 548 оп./сек
CIS ADDNI 1                         3 137 оп./сек
CIS ADDN  1                           600 оп./сек
CIS ADDNI 2                         6 492 оп./сек
CIS ADDN  2                         8 073 оп./сек
MOV 8 word 1                       14 463 оп./сек
MOV 8 word 2                       17 065 оп./сек
CIS MOVCI 8 word 1                 13 971 оп./сек
.

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

Как выглядит описание пары

    ACTION <<CR><LF>\R1(23456.)+R0(12345.) empty   \>, Paired=YES

      LET R1 := #12345.
      LET R0 := #23456.


    ACTION <<CR><LF>\R1(23456.)+R0(12345.)         \>

      LET R1 := #12345.
      LET R0 := #23456.
      LET R1 := R1 + R0

Надо подумать, как сократить описание и количество кода - а то аж 4 слова повторяются - при изменении можно забыть поправить пару...

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

Да и заголовок повторяется.... почти

[Hunta]

- Если написанное может быть понятно неправильно, оно будет кем то (в данном случае - мной) понятно неправильно
- Если написанное НЕ может быть понятно неправильно, оно все равно будет кем то (слава богу - пока не мной) понятно неправильно

Нашёл ошибку (из за неправильно понятого описания дескрипторов CIS) в части тестов CIS.

Блин, я уж начал думать на то, что на моей добавки команда L2Dx работает не правильно Но оказалось - принцип её работы следует именно логичной логике, а не как мне показалось - нелогичному варианту, который сложился у меня в голове Возможно, сказался уровень понимания английского

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

Ну и слегка расширил набор тестов

.RUN SPEED3

Тест быстродействия

R1+R0 classic                     529 528 оп./сек
R1(23456.)+R0(12345.) empty       165 433 оп./сек
R1(23456.)+R0(12345.)             126 565 оп./сек ->     538 695 оп./сек
R1+@R0 classic                    330 002 оп./сек
R1(23456.)+@R0(M-12345.) empty    165 431 оп./сек
R1(23456.)+@R0(M-12345.)          110 383 оп./сек ->     331 724 оп./сек
R0*R0 classic                      40 774 оп./сек
empty 11.*12.                     165 434 оп./сек
11.*12.                            32 667 оп./сек ->      40 704 оп./сек
R2/R0 classic                     140 720 оп./сек
R2-R3(34567.)/R1(321.) empty      126 561 оп./сек
R2-R3(34567.)/R1(321.)             20 125 оп./сек ->      23 930 оп./сек
34567.89022+32109.754321 empty     26 696 оп./сек
34567.89022+32109.754321            9 787 оп./сек ->      15 451 оп./сек
34567.89022*32109.754321 empty     26 696 оп./сек
34567.89022*32109.754321            3 595 оп./сек ->       4 154 оп./сек
34567.89022/32109.754321 empty     26 698 оп./сек
34567.89022/32109.754321            3 499 оп./сек ->       4 026 оп./сек
CIS MULPI 1                           432 оп./сек
CIS MULP  1 empty                  56 831 оп./сек
CIS MULP  1                           434 оп./сек ->         437 оп./сек
CIS MULPI 2                         2 005 оп./сек
CIS MULP  2 empty                  56 849 оп./сек
CIS MULP  2                         2 041 оп./сек ->       2 117 оп./сек
CIS ADDNI 1                         3 144 оп./сек
CIS ADDN  1 empty                  56 847 оп./сек
CIS ADDN  1                         3 227 оп./сек ->       3 421 оп./сек
CIS ADDNI 2                         6 496 оп./сек
CIS ADDN  2 empty                   56 852 оп./сек
CIS ADDN  2                         6 896 оп./сек ->       7 847 оп./сек
MOV 8 word 1 empty                110 383 оп./сек
MOV 8 word 1                       13 876 оп./сек ->      15 871 оп./сек
MOV 8 word 2 empty                110 382 оп./сек
MOV 8 word 2                       17 064 оп./сек ->      20 184 оп./сек
CIS MOVCI 8 word 1                 13 995 оп./сек
CIS MOVC 8 word 2 empty            58 354 оп./сек
CIS MOVC 8 word 2                  16 246 оп./сек ->      22 513 оп./сек
.

Обратил внимание, что команда (символьной) пересылки MOVC работает быстрее (22 513), чем классический (словный) цикл (15871), даже развёрнутый (две инструкции MOV) (20184)

[Alex]

-
Обратил внимание, что команда (символьной) пересылки MOVC работает быстрее (22 513), чем классический (словный) цикл (15871), даже развёрнутый (две инструкции MOV) (20184)

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