3.3. Расчет прироста производительности эвм

В бесконвейерной ЭВМ в среднем на выполнение одной команды требуется 13,76 тактов.

После конвейеризации в среднем требуется 16,56 такта.

16,56 – 13,76 = 2,78

1% 0,1656

x% 2,78

x = 2,78 / 0,1656 = 16,78

Производительность повысилась на 16.78%. Стоимость дополнительной аппаратуры для предварительной выборки мала. Отношение стоимость/производительность весьма привлекательно. Поэтому рационально использовать метод предварительной выборки команды при разработке ЭВМ.

4. Тестовая задача

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

Дано:

ID	0	1	2	3	4	5
Datadec	17	-8	24	0	-2	15
Databin	0..010001	1..11000	0..011000	0..0000	11..1110	0..01111

Получим:

[10001 11000 1111], а в десятичном виде [17 24 15]

4.1. Алгоритм и программа для тестирования эвм

Тестирование заключается в моделировании процесса, выполняющего программу, которая в исходном массиве А двоичных чисел выделяет элементы массива, имеющие четное значение суммы двоичных чисел. Полученные элементы записываются в новый массив В.

Запись данных команд производится с учетом 32 битной разрядности. Команда в памяти хранится начиная с 0x100, исходные данные начиная с 0x400, сохраняемые полученные данные – с 0x500, все необходимые дополнительные и промежуточные данные – с 0х600.

R1 – ссылка на адрес текущей позиции исходного массива А;

R2 – ссылка на адрес текущей позиции нового массива В;

R0 – адрес за последним элементом исходного массива;

С1 – счетчик единиц.

С2 –счетчик сдвигов в элементе массива;

M – ячейка памяти, хранящая маску

W0 – промежуточное значение элемента после сдвига;

N0 – ячейка с нулем;

REG – регистр косвенной адресации;

Akk – аккумулятор;

Тп – триггер пуска.

Приведем алгоритм решения данной задачи в текстовом виде.

Start:

MOVREG R1 // из ячейки R1 загружаем в регистр косвенной адресации, REG ← RAM(R1)

READ [REG] // читаем i-й элемент исходного массива А в аккумулятор, Akk ← RAM[REG] (Акк ← А_i)

L0:

WR W0 // записываем текущий i-й элемент исходного массива А в ячейку-значение для сдига разрядов, RAM(W0) ← Akk (W0 ← A_i)

AND M // логическое умножение по заданной маске,

Akk ← Akk & M, если после этого Akk = 0,

то ZF = 1, иначе ZF = 0

JZ L1 // если ZF = 1, не найдена «1» в младшем разряде, переход на метку L1, IP ← L1

INC C1 // иначе «1» в младшем разряде, увеличиваем счетчик единиц C1 ← C1 + 1

L1:

DEC C2 // уменьшаем счетчик сдвигов у i-го элемента на «1», C2 ← C2 – 1, если после этого C2 – 1 = 0, то ZF = 1, иначе ZF = 0

Z L2 // если ZF = 1, закончились разряды сдвига, то переходим на метку L2, IP ← L2 (12C)

READ W0 // читаем значение для сдвига в аккумулятор,

Akk ← RAM(W0)

SHIFTRZ // выполняем сдвиг вправо на 1 разряд,

Akk ← Akk >> 1

JMP L0 // переходим на метку L0, продолжаем считать «1» в текущем i-м элементе массива, IP ← L0

L2:

READ C1 // читаем число единиц С1, Akk ← C1

AND M // логическое умножение по заданной маске,

Akk ← Akk & M, если после этого Akk = 0,

то ZF = 1, иначе ZF = 0

JZ L3 // если ZF = 1, число четное, переходим на метку L3, IP ← L3

JMP CHECK // иначе число не четное, переходим на метку CHECK, для проверки границы исходного массива, IP ← CHECK

L3:

READ [REG] // читаем i-й элемент исходного массива А в аккумулятор, Akk ← RAM[REG] (Акк ← А_i)

MOVREG R2 // из ячейки R2 загружаем в регистр косвенной адресации, REG ← RAM(R2)

WR[REG] // записываем в i-й элемент нового В массива из аккумулятора, RAM[REG] ← Akk, (B_i ← A_i)

READ R2 // читаем адрес тек. позиции из R2 в аккумулятор,

Akk ← RAM(R2)

ADD4 // смещаем адрес R1 на следующую позицию,

Akk ← Akk + 4

WR R2 // записываем новый адрес в R2, RAM(R2) ← Akk

CHECK:

READ R1 // читаем адрес тек. позиции из R1 в аккумулятор,

Akk ← RAM(R1)

ADD4 // смещаем адрес R1 на следующую позицию,

Akk ← Akk + 4

WR R1 // записываем новый адрес в R1, RAM(R1) ← Akk

CMP R0 // проверка – не вышли ли за границу исходного массива, Akk – R0 = 0 ? ZF = 1 : ZF = 0

JZ Exit // если закончили перебор массива ZF = 1, то переходим на метку Exit, IP ← Exit

READ N0 // читаем ячейку с нулем в аккумулятор,

Akk ← RAM(N0)

WR C1 // обнуляем С1 счетчик единиц, RAM(C1) ← Akk

ADD32 // добавляем к аккумулятору 32, Akk ← Akk + 32

WR C2 // выставляем С2 счетчик сдвигов на 32,

RAM(C2) ← Akk

JMP Start // переход на метку Start, для обработки следующего элемента исходного массива,

IP ← Start

Exit:

HLT // остановка, Тп ← 0

Методы адресации:

1. Прямая.

СА = 00

СА = 01

2. Непосредственная.

СА = 10

3. Косвенная.

СА = 11,

Адрес Нex	Обозначение команды	Объектный код (двоичное представление)	Комментарий
100	Start: MOVREG R1	10000 01 0000000000000 0110 00000000	REG ← RAM(R1)
104	READ [REG]	00100 11 0000000000000 0000 00000000	Akk ← RAM[REG] (Акк ← Аi)
108	L0: WR W0	00011 01 0000000000000 011000011000	RAM(W0) ← Akk (W0 ← Ai)
10C	AND M	10011 01 0000000000000 011000010100	Akk ← Akk & M Akk = 0 ? ZF = 1 : ZF = 0
110	JZ L1	00010 01 0000000000000 000100011000	ZF = 1 ? IP ← L1 (118)
114	INC C1	10111 01 0000000000000 011000001100	C1 ← C1 + 1
118	L1: DEC C2	11000 01 0000000000000 011000010000	C2 ← C2 – 1 C2 – 1 = 0 ? ZF = 1 : ZF = 0
11C	JZ L2	00010 01 0000000000000 000100101100	ZF = 1 ? IP ← L2 (12С)
120	READ W0	00100 01 0000000000000 011000011000	Akk ← RAM(W0)
124	SHIFTRZ	11001 00 0000000000000 000000000000	Akk ← Akk >> 1
128	JMP L0	00101 01 0000000000000 000100001000	IP ← L0 (108)
12C	L2: READ C1	00100 01 0000000000000 011000001100	Akk ← C1
130	AND M	10011 01 0000000000000 011000010100	Akk ← Akk & M Akk = 0 ? ZF = 1 : ZF = 0
134	JZ L3	00010 01 0000000000000 000100111100	ZF = 1 ? IP ← L3 (13С)
138	JMP CHECK	00101 01 0000000000000 000101001100	IP ← CHECK (154)
13C	L3: READ [REG]	00100 11 0000000000000 0000 00000000	Akk ← RAM[REG] (Акк ← Аi)
140	MOVREG R2	10000 01 0000000000000 0110 00000100	REG ← RAM(R2)
144	WR[REG]	00011 11 0000000000000 0000 00000000	RAM[REG] ← Akk (Bi ← Ai)
148	READ R2	00100 01 0000000000000 0110 00000100	Akk ← RAM(R2)
14С	ADD4	10011 10 000000000000000000000 0100	Akk ← Akk + 4
150	WR R2	00011 01 0000000000000 0110 00000100	RAM(R2) ← Akk
154	CHECK: READ R1	00100 01 0000000000000 0110 00000000	Akk ← RAM(R1)
158	ADD4	10011 10 000000000000000000000 0100	Akk ← Akk + 4
15С	WR R1	00011 01 0000000000000 0110 00000000	RAM(R1) ← Akk
160	CMP R0	10101 01 0000000000000 011000001100	Akk – R0 = 0 ? ZF = 1 : ZF = 0
164	JZ Exit	00010 01 0000000000000 000101110100	ZF = 1 ? IP ← Exit(17С)
168	READ N0	00100 01 0000000000000 011000011100	Akk ← RAM(N0)
16С	WR C1	00011 01 0000000000000 011000001100	RAM(C1) ← Akk
170	ADD32	10011 10 0000000000000000000 100000	Akk ← Akk + 32
174	WR C2	00011 01 0000000000000 011000010000	RAM(C2) ← Akk
178	JMP Start	00101 01 0000000000000 000100000000	IP ← Start(100)
17С	Exit: HLT	00000000 00000000 00000000 00000000	Тп ← 0
180

Адрес Нex	Идентификатор	Объектный код (двоичного представления)	Комментарий
400	A0	00000000 00000000 00000000 00010001	17
404	A1	11111111 11111111 11111111 11111000	-8
408	A2	00000000 00000000 00000000 00011000	24
40С	A3	00000000 00000000 00000000 00000000	0
410	A4	11111111 11111111 11111111 11111110	-2
414	A5	00000000 00000000 00000000 00001111	15
….	….	….	….
500	B0	00000011	17
504	B1	00000018	24
508	B2	0000000F	15
….	….	….	….
600	R1	00000400	0х400
604	R2	00000500	0х500
608	R0	00000418	0х418
60C	С1	00000000	0
610	С2	00000020	32
614	M	00000001	1
618	W0	00000000	0
61C	N0	00000000	0