Завдання виконання роботи

МІКРОПРОЦЕСОР

Лабораторна робота №8

Мета роботи: вивчити принцип роботи простого мікропроцесора.

9.1 Короткі теоретичні відомості

Типова архітектура простого мікропроцесора, показана на рис.9.1, називається архітектурою фон Неймана: програми і дані зберігаються у спільній пам’яті у двійковій формі, обчислення також здійснюються у двійковій арифметиці.

Рис.9.1

Вказаний мікропроцесор виконує прості бінарні операції: арифметичні (додавання і віднімання) і логічні (кон’юнкція, диз’юнкція), а також, унарні операції (зсув, інкремент, інверсія).

Більшість операцій мікропроцесора можна поділити на операції двох типів: операції пересилання даних регістр-регістр і операції пересилання регістр-пам’ять або пам’ять-регістр.

Робота мікропроцесора циклічна і для кожної програмної команди один цикл його роботи зводиться до виконання операцій завантаження коду чергової команди із області пам’яті програм, декодування команди (визначення типу команди), завантаження даних із області даних (константи, локальні змінні) і/або із регістра (регістрів), пересилання даних в АЛП для виконання заданої операції і повернення результату виконання команди назад в пам’ять і/або в регістр (регістри). В залежності від складності команда може виконуватись за один або декілька циклів роботи мікропроцесора.

Архітектура мікропроцесора рис. 9.1 використовується в найпростіших і відповідно, найдешевших комп’ютерах, в яких виконання програм виконується інтерпретацією, оскільки безпосередньо апаратурою можуть виконуватись лише найпростіші команди. Більше того, вказана архітектура мікропроцесора може бути повністю реалізована у вигляді програми (емулятора мікропроцесора), яка може виконуватись на будь-якому комп’ютері. Такий підхід використано в Java-технології безпечної передачі і виконання невеликих програм (аплетів) у Веб-середовищі. Для цього створена проста програма-мікропроцесор JVM (віртуальна Java-машина), з можливістю виконання програм із простим набором 256 команд, для представлення яких потрібен всього 1 байт. JVM встановлюється на будь якій із існуючих операційних систем, зокрема, Мac i Windows. Програма–аплет, може бути написана на будь-якій мові високого рівня і скомпільована у програму у вигляді байт-кодів, придатну для виконання на JVM.

Прикладом реалізації мікропроцесора рис.9.1 є цілочисельний мікропроцесор Міс-1. Для вивчення роботи мікропроцесора Міс-1 створено його програмний емулятор Міс1EMU. На рис.9.2 показано структурну схему та графічний інтерфейс емулятора Міс1EMU.

Рис.9.2. 1-спеціалізовані регістри, АЛП і

схема зсуву, 2-пам’ять мікрооперацій, 3-регістр

мікрооперацій (MIR), 4-адресний регістр

мікрооперацій (МРС), 5-часова діаграма мікроциклу, 6-інтерфейс управління роботою мікропроцесора.

З допомогою емулятора Міс1EMU можна складати невеликі програми на рівні мікроасемблера MAL і досліджувати процеси, які відбуваються в тракті даних при їх виконанні в кожному мікроциклі.

Нижче приведена мікропрограма Міс1EMU:

Main1 PC = PC + 1; fetch; goto (MBR) // MBR holds opcode; get next byte;

nop1 // Do nothing

iadd1 MAR = SP = SP - 1; rd // Read in next-to-top word on stack

iadd2 H = TOS // H = top of stack

iadd3 MDR = TOS = H + MDR; wr; goto Main1 // Add top two words; write to top of stack

isub1 MAR = SP = SP - 1; rd // Read in next-to-top word on stack

isub2 H = TOS // H = top of stack

isub3 MDR = TOS = MDR - H; wr; goto Main1 // Do subtraction; write to top of stack

iand1 MAR = SP = SP - 1; rd // Read in next-to-top word on stack

iand2 H = TOS // H = top of stack

iand3 MDR = TOS = H AND MDR; wr; goto Main1 // Do AND; write to new top of stack

ior1 MAR = SP = SP - 1; rd // Read in next-to-top word on stack

ior2 H = TOS // H = top of stack

ior3 MDR = TOS = H OR MDR; wr; goto Main1 // Do OR; write to new top of stack

dup1 MAR = SP = SP + 1 // Increment SP and copy to MAR

dup2 MDR = TOS; wr; goto Main1 // Write new stack word

pop1 MAR = SP = SP - 1; rd // Read in next-to-top word on stack

pop2 PC = PC // Wait for new TOS to be read from memory

pop3 TOS = MDR; goto Main1 // Copy new word to TOS

swap1 MAR = SP - 1; rd // Set MAR to SP - 1; read 2nd word from stack

swap2 MAR = SP // Set MAR to top word

swap3 H = MDR; wr // Save TOS in H; write 2nd word to top of stack

swap4 MDR = TOS // Copy old TOS to MDR

swap5 MAR = SP - 1; wr // Set MAR to SP - 1; write as 2nd word on stack

swap6 TOS = H; goto Main1 // Update TOS

bipush1 SP = MAR = SP + 1 // MBR = the byte to push onto stack

bipush2 PC = PC + 1; fetch // Increment PC, fetch next opcode

bipush3 MDR = TOS = MBR; wr; goto Main1 // Sign-extend constant and push on stack

iload1 H = LV // MBR contains index; copy LV to H

iload2 MAR = H + MBRU; rd // MAR = address of local variable to push

iload3 MAR = SP = SP + 1 // SP points to new top of stack; prepare write

iload4 PC = PC + 1; fetch; wr // Inc PC; get next opcode; write top of stack

iload5 TOS = MDR; goto Main1 // Update TOS

istore1 H = LV // MBR contains index; Copy LV to H

istore2 MAR = H + MBRU // MAR = address of local variable to store into

istore3 MDR = TOS; wr // Copy TOS to MDR; write word

istore4 SP = MAR = SP - 1; rd // Read in next-to-top word on stack

istore5 PC = PC + 1; fetch // Increment PC; fetch next opcode

istore6 TOS = MDR; goto Main1 // Update TOS

wide_iload1 PC = PC + 1; fetch // MBR contains 1st index byte; fetch 2nd

wide_iload2 H = MBRU << 8 // H = 1st index byte shifted left 8 bits

wide_iload3 H = H OR MBRU // H = 16-bit index of local variable

wide_iload4 MAR = H + LV; rd; goto iload3 // MAR = address of local variable to push

wide_istore1 PC = PC + 1; fetch // MBR contains 1st index byte; fetch 2nd

wide_istore2 H = MBRU << 8 // H = 1st index byte shifted left 8 bits

wide_istore3 H = H OR MBRU // H = 16-bit index of local variable

wide_istore4 MAR = H + LV; goto istore3 // MAR = address of local variable to store into

ldc_w1 PC = PC + 1; fetch // MBR contains 1st index byte; fetch 2nd

ldc_w2 H = MBRU << 8 // H = 1st index byte << 8

ldc_w3 H = H OR MBRU // H = 16-bit index into constant pool

ldc_w4 MAR = H + CPP; rd; goto iload3 // MAR = address of constant in pool

iinc1 H = LV // MBR contains index; Copy LV to H

iinc2 MAR = H + MBRU; rd // Copy LV + index to MAR; Read variable

iinc3 PC = PC + 1; fetch // Fetch constant

iinc4 H = MDR // Copy variable to H

iinc5 PC = PC + 1; fetch // Fetch next opcode

iinc6 MDR = H + MBR; wr; goto Main1 // Put sum in MDR; update variable

goto1 OPC = PC - 1 // Save address of opcode.

goto2 PC = PC + 1; fetch // MBR = 1st byte of offset; fetch 2nd byte

goto3 H = MBR << 8 // Shift and save signed first byte in H

goto4 H = H OR MBRU // H = 16-bit branch offset

goto5 PC = H + OPC; fetch // Add offset to OPC

goto6 goto Main1 // Wait for fetch of next opcode

iflt1 MAR = SP = SP - 1; rd // Read in next-to-top word on stack

iflt2 OPC = TOS // Save TOS in OPC temporarily

iflt3 TOS = MDR // Put new top of stack in TOS

iflt4 N = OPC; if (N) goto T; else goto F // Branch on N bit

ifeq1 MAR = SP = SP - 1; rd // Read in next-to-top word of stack

ifeq2 OPC = TOS // Save TOS in OPC temporarily

ifeq3 TOS = MDR // Put new top of stack in TOS

ifeq4 Z = OPC; if (Z) goto T; else goto F // Branch on Z bit

if_icmpeq1 MAR = SP = SP - 1; rd // Read in next-to-top word of stack

if_icmpeq2 MAR = SP = SP - 1 // Set MAR to read in new top-of-stack

if_icmpeq3 H = MDR; rd // Copy second stack word to H

if_icmpeq4 OPC = TOS // Save TOS in OPC temporarily

if_icmpeq5 TOS = MDR // Put new top of stack in TOS

if_icmpeq6 Z = OPC - H; if (Z) goto T; else goto F // If top 2 words are equal, goto T, else goto F

T OPC = PC - 1; fetch; goto goto2 // Same as goto1; needed for target address

F PC = PC + 1 // Skip first offset byte

F2 PC = PC + 1; fetch // PC now points to next opcode

F3 goto Main1 // Wait for fetch of opcode

invokevirtual1 PC = PC + 1; fetch // MBR = index byte 1; inc. PC, get 2nd byte

invokevirtual2 H = MBRU << 8 // Shift and save first byte in H

invokevirtual3 H = H OR MBRU // H = offset of method pointer from CPP

invokevirtual4 MAR = H + CPP; rd // Get pointer to method from CPP area

invokevirtual5 OPC = PC + 1 // Save Return PC in OPC temporarily

invokevirtual6 PC = MDR; fetch // PC points to new method; get parameters count

invokevirtual7 PC = PC + 1; fetch // Fetch 2nd byte of parameter count

invokevirtual8 H = MBRU << 8 // Shift and save first byte in H

invokevirtual9 H = H OR MBRU // H = number of parameters

invokevirtual10 PC = PC + 1; fetch // Fetch first byte of # locals

invokevirtual11 TOS = SP - H // TOS = address of OBJREF - 1

invokevirtual12 TOS = MAR = TOS + 1 // TOS = address of OBJREF (new LV)

invokevirtual13 PC = PC + 1; fetch // Fetch second byte of # locals

invokevirtual14 H = MBRU << 8 // Shift and save first byte in H

invokevirtual15 H = H OR MBRU // H = # locals

invokevirtual16 MDR = H + SP + 1; wr // Overwrite OBJREF with link pointer

invokevirtual17 MAR = SP = MDR // Set SP, MAR to location to hold old PC

invokevirtual18 MDR = OPC; wr // Save old PC above the local variables

invokevirtual19 MAR = SP = SP + 1 // SP points to location to hold old LV

invokevirtual20 MDR = LV; wr // Save old LV above saved PC

invokevirtual21 PC = PC + 1; fetch // Fetch first opcode of new method.

invokevirtual22 LV = TOS; goto Main1 // Set LV to point to LV Frame

ireturn1 MAR = SP = LV; rd // Reset SP, MAR to get link pointer

ireturn2 PC = PC // Wait for read

ireturn3 LV = MAR = MDR; rd // Set LV to link ptr; get old PC

ireturn4 MAR = LV + 1 // Set MAR to read old LV

ireturn5 PC = MDR; rd; fetch // Restore PC; fetch next opcode

ireturn6 MAR = SP // Set MAR to write TOS

ireturn7 LV = MDR // Restore LV

ireturn8 MDR = TOS; wr; goto Main1 // Save return value on original top of stack

halt1 goto halt1

out1 OPC=H=-1 // compute IO address

out2 OPC=H+OPC // -2

out3 OPC=H+OPC // -3

out4 OPC=H+OPC // -4

out5 OPC=H+OPC // -5

out6 MAR=H+OPC // -6

out7 MDR=TOS; wr // write to output

out8 nop

out9 MAR=SP=SP-1; rd // decrement stack pointer

out10 nop

out11 TOS=MDR; goto Main1

in1 OPC=H=-1 // compute IO address

in2 OPC=H+OPC // -2

in3 OPC=H+OPC // -3

in4 OPC=H+OPC // -4

in5 OPC=H+OPC // -5

in6 MAR=H+OPC;rd // compute IN address ; read from input

in7 MAR=SP=SP+1 // increment SP; wait for read

in8 TOS=MDR;wr ; goto Main1 // Write

Нижче приведено приклад робочого коду мікропрограми обчислення виразу: i=j+k, якщо j<k, то i=k:

h = 0

mar=h;rd

mdr

tos=mdr

h = h + 1

mar=h;rd

mdr

h=tos

tos=mdr+h

mdr=tos

h=1

h=h+1

mar=h;wr

mdr

h=1

mar=h;rd

mdr

tos=mdr

h=0

mar=h;rd

mdr

h=tos

h=mdr-h

tos=h

n=tos

if (n)goto L;else goto P

L h=1

h=h+1

mar=h;rd

mdr

P h=1

mar=h;rd

mdr

На основі архітектури мікропроцесора Міс-1 розроблено цілочисельну віртуальну Java-машину (IJVM): систему команд, компілятор і емулятор, які дозволяють детально вивчити мікроархітектурний рівень побудови стекового комп’ютера з інтерпретацією команд.

На рис.9.3 показано графічний інтерфейс емулятора Міс1IJVM. Основною відмінністю цього емулятора від емулятора Міс1EMU є введення вікон візуалізації основної пам’яті комп’ютера: області констант (Constant Pool), програмної області (Method Area) і стекової області (Stack), а також, вікна візуалізації программного коду із командами IJVM та вікна введення/виведення даних (Standart I/O).

Рис.9.3

З допомогою даного емулятора можна складати програми на асемблері IJVM, транслювати їх на рівень виконавчих байт-кодів і досліджувати що відбувається в процесі виконання цих програм в тракті даних і у виділених областях основної пам’яті (область констант, область програм, стек).

Список команд IJVM:

Тут розмір операндів byte, const, varnum = 1байт, а операндів disp, index, offset = 2 байти.

Приклад невеликої робочої програми на мові асемблера Java:

/**********************************************************/

Програма написана для обчислення формули і = (j+k+4)*2 на

мові асемблера IJVM. Введення даних j, k та виведення значень і цієї

формули здійснюється у вікні Standard I/O.

/**********************************************************/

.constant

OBJREF 0

.end-constant

// i= (j+k+4)*2

.method function(j,k)

.var i

.end-var

LDCW OBJREF

ILOAD j

ILOAD k

IADD

ISTORE i

IINC i 4

ILOAD i

DUP

IADD

IRETURN

.end-method

.main

IN

IN

invokevirtual function

out

halt

.end-main.

Завдання виконання роботи

9.2.1. Робота з емулятором Mic-1EMU.

- освоїти роботу з емулятором Mic-1EMU;

- скласти програму на мікроасемблері Міс-1 обчислення наступних функцій згідно завдань таблиці 9.1.

Таблиця 9.1

Значення № функцій:

1. i=(j+k+4)

2. i=(j+k+4)*2

3. i=(j+k+4)*3

4. i=(j+k+m+n+4)*3.

- подати у звіті код працюючої програми

-виконати обчислення і подати у звіті його результат.

9.2.2.Робота з емулятором Mic-1IJVM.

- освоїти роботу з емулятором Mic-1IJVM;

- скласти програми на асемблері IJVM обчислення наступних функцій згідно завдань таблиці 9.2.

Таблиця 9.2

Значення № функцій:

1. i=(j+k)*m+10

2. i=(j+k)*(2+m-n)

3. i=j!

4. Порівняти вирази j+k і m+n і вивести максимальне

5. Порівняти вирази k+4 і 2(j+k). Якщо k+4 <2(j+k), то обчислити i=j-1, якщо ні, то присвоїти i= k.

- подати у звіті код працюючої програми

-виконати обчислення і подати у звіті його результат.

9.3. Контрольні завдання.

9.3.1 Пояснити як організована пам’ять в мікропроцесорі IJVM.

9.3.2. Пояснити як здійснюється виконання програм IJVM.

9.3.3. Пояснити що таке стек та як здійснюються обчислення в стековому комп’ютері.

9.3.4. Намалювати структурну схему IJVM.

Поиск по сайту: