Подякувати Студентському архіву довільною сумою
Admin
26.02.2023 12:38
Дякуємо, що користуєтесь нашим архівом!
Проектування комп’ютера
Інформація про навчальний заклад
ВУЗ:
Національний університет Львівська політехніка
Інститут:
Не вказано
Факультет:
КН
Кафедра:
Не вказано
Інформація про роботу
Рік:
2017
Тип роботи:
Курсова робота
Предмет:
Архітектура комп'ютерів
Частина тексту файла (без зображень, графіків і формул):
Міністерство освіти і науки
Національний університет „Львівська політехніка”
Кафедра EОМ
Курсова робота
На тему: «Проектування комп’ютера»
з дисципліни: “ Архітектура комп’ютера”
2017
Зміст
1.Анотація: 3
2. Вихідні дані на проектування: 7
3. Проектування комп’ютера згідно заданого варіанту: 9
3.1 Проектування програми перетворення асемблерної програми у послідовність відповідних машинних інструкцій: 9
3.2 Проектування поведінкового симулятору результуючого машинного коду: 13
4.Результати роботи: 20
5. Висновок 31
6. Використана література. 32
7.Додатки 33
Анотація:
В ході виконання даної курсової роботи розглядається симулятор та асемблер 32 розрядного CISC комп’ютера (комп’ютера зі складною системою команд).
Для процесора комп’ютера зі складною системою команд характерні наступні особливості:
Виконання команди за багато тактів, оскільки для цього потрібно здійснити багаторазові операції звернення до основної пам’яті та до програмно – доступних регістрів процесора;
Орієнтація АЛП на виконання великої кількості операцій, що пов’язано з розширеним складом системи команд;
Складна система розпізнавання команди, що пов’язано з великою кількістю методів адресації та великою кількістю форматів команд різної розрядності;
Програмне дешифрування команд з метою зменшення затрат обладнання;
Складна організація конвеєризації виконання команд, що пов’язано, в першу чергу, з різнотипністю їх виконання;
Орієнтація структури на виконання команд типу регістр – пам’ять та пам’ять – пам’ять.
Недоліки CISC архітектури:
Висока вартість апаратної частини;
Важкість з розпаралелюванням обчислень.
Комп’ютер, який розробляється в курсовій роботі, міститиме 8 регістрів (0-вий регістр завжди зберігає 0) та 65536 комірок пам’яті по 32 розряди. Набір машинних інструкцій складатемиться з 20 команд. Серед яких:
4 арифметчних команд
3 логічні команди
7 команд керування
3 команди роботи з регістром переносу (CF)
3 команди роботи з додатковим способом адресації. (Непряма адресація)
Основні принципи архітектури, які запропонував Джон фон Нейман:
1. Інформація кодується в двійковому представленні.
2. Інформація в комп’ютері ділиться на команди і дані.
3. Різнотипні за змістом слова розрізняються за способом застосування, а не по способу кодування.
4. Слова інформації розміщаються в комірках пам’яті та ідентифікуються номерами комірок – адресами слів.
5. Пам’ять є лінійною.
6. Пам’ять має довільну адресацію.
7. Команди і дані зберігаються в одній пам’яті.
8. Алгоритми представляються у вигляді послідовності керуючих слів, як називаються командами. Команда визначається найменуванням операції та слів інформації, які в ній приймають участь. Алгоритм записаний у вигляді послідовності команд, називається програмою.
9. Весь набір виконуваних комп’ютером команд називається системою команд комп’ютера.
10. Виконання обчислень, які визначені алгоритмом, являють собою послідовне виконання команд в порядку визначеному програмою.
Основні елементи процесора - арифметико-логічний пристрій, пристрій керування і регістрова пам'ять або, як її ще називають, надоперативний запам'ятовуючий пристрій. До складу регістрової пам'яті, в свою чергу, входять наступні вузли - програмний лічильник, регістри: адреси, команди, даних, слова стану програми, а також регістровий файл, який складається з програмно доступних регістрів.
Cтруктура регістрової (надоперативної) пам'яті процесора складається з регістрів спеціального та зального призначення. До регістрів спеціального призначення належать:
регістри адреси (РгА);
регістри команд (РгК);
програмний лічильник(ПЛ)
регістри даних (РгД).
РгА зберігає адресу даного або команди при зверненні до основної пам'яті. РгД зберігає операнд при його запису або зчитуванні з основної пам'яті. В ролі операнда може бути дане, команда або адреса. РгК зберігає команду після її зчитування з основної пам'яті. ПЛ підраховує команди та зберігає адресу поточної команди. Комп'ютер з архітектурою Джона фон Неймана має один програмний лічильник.
Більшість комп'ютерів мають в складі процесора тригери для зберігання бітів стану процесора, або, як їх іще називають, прапорців. Кожен прапорець має спеціальне призначення. Частина прапорців вказує на результати арифметичних і логічних операцій: додатній результат (Р), від'ємний результат (N), нульовий результат (Z), перенос (С), арифметичне переповнення (V), і т. д.
Кожен процесор має власний набір команд, який називається системою команд процесора.
Система команд характеризується трьома аспектами:
формат,
способи адресації,
система операцій.
Форматом команди – є довжина команди, кількість, розмір, положення, призначення та спосіб кодування полів. Команди мають включати наступні види інформації:
тип операції, яку необхідно реалізувати в даній команді (поле команду операції - КОП)
місце в пам’яті звідки треба взяти перший операнд (А1);
місце в пам’яті звідки треба взяти другий операнд (А2);
місце в пам’яті куди треба помістити результат (А3).
2. Вихідні дані на проектування:
Перелік завдань:
Розробити 8 додаткових інструкцій без використання регістрів стану:
3 арифметичні;
3 логічні;
2 керування.
Розробити 3 додаткові інструкції з використанням регістрів стану.
Передбачити інструкції, які підтримують додатковий тип адресації.
Мій варіант – 3, отже мої завдання:
№
Арифметичні
Логічні
Керування
Прапорці
Адресація
1
2
3
4
5
6
7
8
1
2
3
3
3
5
6
1
3
5
1
5
CF
1
2
5
3
Конкретизація завдань:
Арифметичні:
3 DIV regA regB destReg - Беззнакове ділення regA на regB. destReg=regA/regB.
5 IMUL regA regB destReg - Знакове множення regA на regB. destReg=regA*regB.
6 XADD regA regB destReg - Додати і обміняти операнди місцями regA і regB. destReg=regA+regB regA<=>regB.
Логічні:
1 AND regA regB destReg - Побітове логічне «І» regA та regB.
destReg=regA & regB.
3 SHL regA regB destReg - Логічний зсув вліво regA на regB.
destReg=regA << regB.
5 CMPE regA regB destReg - Порівняти regA і regB.
destReg= regA == regB
Керування:
1 JMA regA regB offSet - Беззнакове більше if (regA> regB) PC=PC+1+offSet
5 JMG regA regB offSet - Знакове більше if (regA > regB) PC=PC+1+offSet
Прапорці: (CF, регістр переносу)
1 ADC regA regB destReg - Додавання з переносом: destReg=regA+regB+CF.
2 SBB regA regB destReg - Віднімання з врахуванням переносу. Результат у destReg. (destReg = regA – regB – CF).
5 STС - Встановити СF =1
Адресація:
3 – Непряма - Робота з вказівниками: якщо в А — адреса вказівника р, то ефективна адреса — це значення *p.
1 LOAD regA regB offSet - Завантаження в регістр regB значення *(offSed + regA).
2 SAVE regA regB offSet - Завантаження з регістр regB значення до offSed + regA.
2 GETA regA regB offSet - Завантаження в регістр regB значення адреси offSed + regA.
3. Проектування комп’ютера згідно заданого варіанту:
3.1 Проектування програми перетворення асемблерної програми у послідовність відповідних машинних інструкцій:
Перш ніж почати роботу над цією програмою, потрібно визначитись з синтаксисом асемблерної програми, яка буде використовуватись як вхідні дані програми – перетворювача.
Отже, формат лінійки асемблерного коду буде наступний (<пробіл> означає послідовність табуляцій і/або пробілів):
мітка <пробіл> інструкція<пробіл>поле№1<пробіл> поле№2<пробіл> поле№3<пробіл>коментар
Де, поле№1-№3 – номер регістру або адреса (символьна або числова) в залежності від команди.
Алгоритм перетворення асемблерних команд у машинні інструкції передбачає 2 «проходи» по вхідній текстовій (асемблерній) програмі. У процесі першого проходу програма перевіряє коректність синтаксису команд (Перевіряє кожну вхідну команду на наявність її у множині команд комп’ютера (Простіше кажучи, перевіряє, чи ця команда відома комп’ютеру), перевіряє відповідність кількості операндів вхідної команди та задекларованої кількості операндів для цієї команди, правильність зазначених у команді операндів (Операдом можуть бути: регістр, символьне зміщення (мітка), числове зміщення).
Рис. 1. Схема першого проходу асемблера
Примітка до рисунку 1: блок readAndParse зчитує з вхідного файлу 1 рядок і отримує з нього значення таких полів: мітка, код операції, операнд 1 (якщо операція цього потребує), операнд 2 (якщо операція цього потребує) та операнд 3 (якщо операція цього потребує). На цьому етапі перевіряється наявність цієї команди у комп’ютері, кількість та тип операндів. В залежності від команди, операнд (операнди) перевіряються на коректність (номеру регістра (для команд, які працюють з регістрами), символьної або числової адреси (для команд завантаження, зберігання даних, команд керування і т.д., де одним з операндів є адреса у пам’яті))).
Блок testRegArg перевіряє правильність номеру регістру. На схемі, до цього блоку підведені всі 3 регістри. Це було обумовлено можливістю використання команд, в яких всі 3 операнди - регістри. (ADD reg1 reg2 reg3, DIV reg1 reg2 reg3, AND reg1 reg2 reg3 і т.д.)
testAddrArg перевіряє коректність вказання адреси (символьної або числової). На схемі, до цього блоку підведені тільки перший та третій операнди. Це обумовлено специфікацією команд розробленого комп’ютера. Тобто, у наборі інструкцій мого комп’ютера немає такої інструкції, у якій другим операндом буде адреса. Перший операнд, як адресу, може використовувати тільки одна інструкція - .fill (збереження у мітці числа або адреси). Приклад цієї операції:
one .fill 1 – Цей приклад «покладе» за адресою, де знаходиться ця команда одиницю. Доступитись до цієї адреси можна буде за допомогою мітки one. Грубо кажучи, виконалась операція one = 1;
one .fill start – У цьому випадку в адресі, де знаходиться ця команда збережеться адреса мітки start.
З третім операндом, як адресою, працюють операції завантаження\збереження даних, операції керування (lw,sw,jmae,jmle,beq)
Program.as у схемі – це текстовий файл з програмою.
У процесі другого проходу рядку програми виконується генерування відповідних машинних команд, тобто числового еквіваленту асемблерним командам. Зазираючи глибше у цей процес, можна сказати, що незалежно від операції, її код зсувається вліво на 22 розряди, цим самим, лишаючи за кодом 22 розряди, які використовуються для операндів (якщо операція їх потребує), 3 розряди для першого операнду, 3 – для другого і 16 – для третього (регістр або адреса)).
Рис. 2. Схема другого проходу асемблера.
Блок isNumber перевіряє, чи є операнд числом. Якщо так, то програма записує це число у відповідній позиції адресного поля команди. Якщо ні, то переходить до блоку translateSymbol
translateSymbol – Підставляє замість символьної адреси (мітки) числову. Числова адреса береться з, сформованої на першому проході, своєрідної таблиці міток, де вказані адреси для кожної мітки. Після виконання переходить до блоку формування машинного коду.
Утворення машинного коду – Формує машинний код з коду операції та операндів. На виході цього блоку утворюється 2 файли:
Program.mc – файл з послідовністю машинних інструкцій, який буде читатися програмою – симулятором.
BRValue.txt – файл, у який було занесено адреса команди HALT. Цей файл потрібен для реалізації альтернативного способу адресації. (Відносна адресація).
3.2 Проектування поведінкового симулятору результуючого машинного коду:
Ця програма покликана виконати послідовність машинних команд, які були сформовані програмою – перетворювачем (пп. 3.1). По суті, це виконуюча частина мого «Спрощеного комп’ютера».
Рис. 3. Функціональна схема симулятора.
Симулятор починає свою роботу ініціалізацією пам’яті та регістрів нульовими значеннями. Наступним кроком відбувається завантаження програми у машинних кодах у пам’ять з текстового файлу. Далі відбувається покрокове виконання програми (один крок – одна команда) та вивід стану у файл. (під виводом стану мається на увазі вивід вмістимого всіх задіяних комірок пам’яті та регістрів, вмістиме прапорця CF вмістиме ПЛ.
У блоці stateStruct зберігається стан машини – значення регістрів, пам’яті, програмного лічильника та прапорців (CF)
Run – виконує вибірку інструкції з пам’яті, декодує інструкцію та виконує її. На етапі декодування викликається блок convertNum, який перетворює 16 розрядне (2 байтне) число у число int, прийняте у «Сі-подібних» мовах як 32 розрядне (4 байтне). Також, у кінці кожного run циклу викликається блок printState, який «звітує» про пророблену роботу. (виводить стан машини, про це було зазначено вище).
Мені було поставлене завдання розробити додатковий спосіб адресації та передбачити, що 3 інструкції його підтримують.
Адресація згідно варіанту – Непряма.
Непряма адресація означає роботу з вказівниками: якщо в А — адреса вказівника р, то ефективна адреса — це значення *p, тобто значення вказівника це певна адреса для якої існує опереція «розіменування», сутність якої у отримання значення розміщеного за цією адресою. В моїй програмі вказівники ідентичні звичайним змінним а роботу з вказівниками підтримують такі команди як load, save i geta.
Рис. 4. Функціональна схема спрощеного комп’ютера.
Коментар до рисунку 4:
ALU – арифметико – логічний пристрій.
instReg – зберігає команду після її зчитування з основної пам’яті.
RegisterFile – зберігає значення регістрів.
Memory – пам’ять.
CF – регістр переносу.
ProgramCounter – підраховує команди та зберігає адресу поточної команди.
ПК – пристрій керування.
В спрощеному комп’ютері (СК) в пам’яті зберігаються, як дані так і інструкції.
Кожна інструкція закодована числом. Це число складається з декількох полів: поле назви команди чи код операції (КОП) та полів операндів. В СК є два види пам’яті: загальна пам’ять, та регістрова пам’ять. В загальній пам’яті зберігаються інструкції програми тадані над якими оперують інструкції. В регістровий пам’яті зберігаються дані над якими виконуються інструкції. У реальних комп’ютерах регістрова пам’ять є малою зарозмірами та швидкою, працює на швидкості ядра процесора, загальна пам’ять є великою за розміром, але набагато повільніша за ядро процесора. Регістрова пам’ять підтримує лише пряму адресацію, загальна пам’ять підтримує декілька типів адресації.
У СК є 8 регістрів по 32 розряди, пам’ять складається з 65536 слів по 32 розряди.Одже СК є 32 розрядним комп’ютером. Він підтримує 17 інструкцій, кожна з яких розписана нижче. У СК є спеціальний регістр лічільник команд (ЛК). За прийнятою домовленістю 0вий регістр завжди містить 0 (це не обмовлено апаратними вимогами проте асемблерна програма ніколи не має змінювати значення 0ого регістра, який ініціалізуються 0). СК підтримує 5 форматів інструкцій. Біти 31-25 не використовує жодна інструкція тому вони завжди мають дорівнювати 0.
5 форматів команд та їх структура (таблиця 1):
Тип
Які команди входять до цього типу
Структура інструкції (біти)
31-25
24-22
21-19
18-16
15-3
2-0
R
add,div,imul,xadd,and,shl,cmpl,adc, sbb
-
Код
операції
regA
regB
destReg
I
lw,sw,beq,jma,jmg,load,save,geta
-
Код
операції
regA
regB
offset
J
jalr
-
Код
Операції
regA
regB
-
-
O
halt, stc
-
Код
Операції
-
-
-
-
Таблиця 1. Формати команд та їх структура
Множина інструкцій спроектованого спрощеного комп’ютера (таблиця 2):
№
Пп
Мнемонічний код інструкції
Двійковий код інструкції
Сутність інструкції
0
add regA regB destReg
00000
Додає вміст регістру regA до вмісту regB, та зберігає в destReg
1
nand regA regB destReg
00001
Виконує логічне побітове І-НЕ вмісту regA з вмістом regB, та зберігає в destReg
2
lw regA regB offset
00010
Завантажує regB з пам’яті. Адреса пам’яті формується додаванням зміщення до вмісту regA.
3
sw regA regB offset
00011
Зберігає вміст регістру regB в пам’ять. Адреса пам’яті формується додаванням зміщення до вмісту regA.
4
beq regA regB offset
00100
Якщо вміст регістрів regA та regB однаковий, виконується перехід на адресу програмний лічильник(ПЛ) + 1+зміщення, в ПЛ зберігається адреса поточної тобто beq інструкції.
5
jalr regA regB
00101
Спочатку зберігає ПЛ+1 в regB, в ПЛ адреса поточної (jalr) інструкції. Виконує перехід на адресу, яка зберігається в regA. Якщо в якості regA regB задано один і той самий регістр, то спочатку в цей регістр запишеться ПЛ+1, а потім виконається перехід до ПЛ+1.
6
halt
00110
Збільшує значення ПЛ на 1, потім припиняє виконання, стимулятор має повідомляти, що виконано зупинку.
7
div regA regB destReg
00111
Беззнакове ділення regA на regB. destReg=regA/regB.
8
imul regA regB destReg
01000
Знакове множення regA на regB. destReg=regA*regB.
9
xadd regA regB destReg
01001
Додати і обміняти операнди місцями regA і regB. destReg=regA+regB regA<=>regB.
10
and regA regB destReg
01010
Побітове логічне «І» regA та regB.
destReg=regA & regB.
11
shl regA regB destReg
01011
Логічний зсув вліво regA на regB.
destReg=regA << regB.
12
cmpe regA regB destReg
01100
Порівняти regA і regB.
destReg= regA == regB
13
jma regA regB offSet
01101
Беззнакове більше if (regA> regB) PC=PC+1+offSet
14
jmg regA regB offSet
01110
Знакове більше if (regA > regB) PC=PC+1+offSet
15
adc regA regB destReg
01111
Додавання з переносом: destReg=regA+regB+CF.
16
sbb regA regB destReg
10000
Віднімання з переносом: destReg=regA-regB-СF
17
stс
10001
Встановити СF =1
18
load regA regB offset
10010
Завантаження в регістр regB значення *(offSed + regA).
19
save regA regB offset
10011
Завантаження з регістр regB значення до offSed + regA.
20
geta regA regB offset
10100
Завантаження в регістр regB значення адреси offSed + regA.
Результати роботи:
Тест №1:
Команда DIV.
Поділити число a на число b. Програма виходить з циклу якщо команда div виконується коректно.
Код програми:
lw 0 1 a
lw 0 2 b
lw 0 3 Res
start div 1 2 2
beq 2 3 end
beq 0 0 start
end sw 0 1 Res
halt
a .fill 36
b .fill 12
Res .fill 3
Результат:
Початковий стан машини:
Кінцевий стан машини:
state:
pc 0
memory:
mem[ 0 ] 8454152
mem[ 1 ] 8519689
mem[ 2 ] 8585226
mem[ 3 ] 30015490
mem[ 4 ] 18022401
mem[ 5 ] 16842749
mem[ 6 ] 12648458
mem[ 7 ] 25165824
mem[ 8 ] 36
mem[ 9 ] 12
mem[ 10 ] 3
registers:
reg[ 0 ] 0
reg[ 1 ] 0
reg[ 2 ] 0
reg[ 3 ] 0
reg[ 4 ] 0
reg[ 5 ] 0
reg[ 6 ] 0
reg[ 7 ] 0
flags:
CF[ 0 ] 0
end state
state:
pc 8
memory:
mem[ 0 ] 8454152
mem[ 1 ] 8519689
mem[ 2 ] 8585226
mem[ 3 ] 30015490
mem[ 4 ] 18022401
mem[ 5 ] 16842749
mem[ 6 ] 12648458
mem[ 7 ] 25165824
mem[ 8 ] 36
mem[ 9 ] 12
mem[ 10 ] 36
registers:
reg[ 0 ] 0
reg[ 1 ] 36
reg[ 2 ] 3
reg[ 3 ] 3
reg[ 4 ] 0
reg[ 5 ] 0
reg[ 6 ] 0
reg[ 7 ] 0
flags:
CF[ 0 ] 0
end state
Коментар: Відбувається беззнакове ділення оперенда 1 на 2. Умовою виходу з циклу є правильний результат ділення.
Візьмем операнди, як у програмі:
а = 36, b = 12. У результат (mem[3]) записалось число 36/ 12 = 3. Програма працює вірно.
Тест №2:
Команди AND та XADD.
Виконати побітове «і» над а і b та поділити а на b, поміняти операнди місцями і записати результат у Res.
lw 0 1 a
lw 0 2 b
lw 0 3 Res
and 1 2 1
xadd 1 2 3
sw 0 3 Res
End halt
a .fill 6
b .fill 2
Res .fill 0
Результат:
Початковий стан машини:
Кінцевий стан машини:
state:
pc 0
memory:
mem[ 0 ] 8454151
mem[ 1 ] 8519688
mem[ 2 ] 8585225
mem[ 3 ] 42598401
mem[ 4 ] 38404099
mem[ 5 ] 12779529
mem[ 6 ] 25165824
mem[ 7 ] 6
mem[ 8 ] 2
mem[ 9 ] 0
registers:
reg[ 0 ] 0
reg[ 1 ] 0
reg[ 2 ] 0
reg[ 3 ] 0
reg[ 4 ] 0
reg[ 5 ] 0
reg[ 6 ] 0
reg[ 7 ] 0
flags:
CF[ 0 ] 0
end state
state:
pc 7
memory:
mem[ 0 ] 8454151
mem[ 1 ] 8519688
mem[ 2 ] 8585225
mem[ 3 ] 42598401
mem[ 4 ] 38404099
mem[ 5 ] 12779529
mem[ 6 ] 25165824
mem[ 7 ] 6
mem[ 8 ] 2
mem[ 9 ] 4
registers:
reg[ 0 ] 0
reg[ 1 ] 2
reg[ 2 ] 2
reg[ 3 ] 4
reg[ 4 ] 0
reg[ 5 ] 0
reg[ 6 ] 0
reg[ 7 ] 0
flags:
CF[ 0 ] 0
end state
Коментар: В якості першого операнду було взято число 6, другого – 2. Спочатку з числом 6 ( 1 регістр ) і числом 2( 2 регістр ) виконуємо побітове «І», результат записуємо у регістр 1. У регістрі 1 буде число 2, 2 – 2.
110
&
010
010
Потім виконаємо додавання. Команда також після виконання ділення поміняє місцями вмістиме 1 та 2 регістрів, отже після виконання цієї команди, у регістрі 1 буде число 2, 2 – 2, 3 – 4. Далі, за програмою, комп’ютер збереже вмістиме регістру 3(3) у змінну Res. 6 & 2 = 3. 2 + 2 = 4(mem[9]). Програма працює вірно.
Тест №3.
Команди SHL.
Виконати: a << b.
Код програми:
lw 0 1 a
lw 0 2 b
lw 0 3 Res
shl 1 2 1
halt
a .fill 64
b .fill 1
Res .fill 4
Результат:
Початковий стан машини:
Кінцевий стан машини:
state:
pc 0
memory:
mem[ 0 ] 8454149
mem[ 1 ] 8519686
mem[ 2 ] 8585223
mem[ 3 ] 46792705
mem[ 4 ] 25165824
mem[ 5 ] 64
mem[ 6 ] 1
mem[ 7 ] 4
registers:
reg[ 0 ] 0
reg[ 1 ] 0
reg[ 2 ] 0
reg[ 3 ] 0
reg[ 4 ] 0
reg[ 5 ] 0
reg[ 6 ] 0
reg[ 7 ] 0
flags:
CF[ 0 ] 0
end state
state:
pc 5
memory:
mem[ 0 ] 8454149
mem[ 1 ] 8519686
mem[ 2 ] 8585223
mem[ 3 ] 46792705
mem[ 4 ] 25165824
mem[ 5 ] 64
mem[ 6 ] 1
mem[ 7 ] 4
registers:
reg[ 0 ] 0
reg[ 1 ] 128
reg[ 2 ] 1
reg[ 3 ] 4
reg[ 4 ] 0
reg[ 5 ] 0
reg[ 6 ] 0
reg[ 7 ] 0
flags:
CF[ 0 ] 0
end state
Коментар: a – 64;
Результат буде 10000002 (6410) = 100000002 (12810)(reg[1]). Програма працює правильно.
Тест №4:
Команда CMPЕ.
Порівняння двох чисел на рівність. Збереження результату в регістрі.
Код програми:
lw 0 1 a
lw 0 2 b
lw 0 3 c
lw 0 4 Res
start cmpe 1 2 4
beq 4 3 end
beq 1 1 start
end halt
a .fill 6
b .fill 6
c .fill 1
Res .fill 0
Результат:
Початковий стан машини:
Кінцевий стан машини:
state:
pc 0
memory:
mem[ 0 ] 8454152
mem[ 1 ] 8519689
mem[ 2 ] 8585226
mem[ 3 ] 8650763
mem[ 4 ] 50987012
mem[ 5 ] 19070977
mem[ 6 ] 17432573
mem[ 7 ] 25165824
mem[ 8 ] 6
mem[ 9 ] 6
mem[ 10 ] 1
mem[ 11 ] 0
registers:
reg[ 0 ] 0
reg[ 1 ] 0
reg[ 2 ] 0
reg[ 3 ] 0
reg[ 4 ] 0
reg[ 5 ] 0
reg[ 6 ] 0
reg[ 7 ] 0
flags:
CF[ 0 ] 0
end state
state:
pc 8
memory:
mem[ 0 ] 8454152
mem[ 1 ] 8519689
mem[ 2 ] 8585226
mem[ 3 ] 8650763
mem[ 4 ] 50987012
mem[ 5 ] 19070977
mem[ 6 ] 17432573
mem[ 7 ] 25165824
mem[ 8 ] 6
mem[ 9 ] 6
mem[ 10 ] 1
mem[ 11 ] 0
registers:
reg[ 0 ] 0
reg[ 1 ] 6
reg[ 2 ] 6
reg[ 3 ] 1
reg[ 4 ] 1
reg[ 5 ] 0
reg[ 6 ] 0
reg[ 7 ] 0
flags:
CF[ 0 ] 0
end state
Коментар: у reg[4] лежить результат. Вхідні операнди: а = 6, b = 6, c = 1. Програма порівняла на рівність регістри 1 і 2 та зберегла результат в регіст 4. Програма працює правильно.
Тест №5:
Команда JMА.
Додавання а до b і збереження результату в регістр поки модуль їх суми не перевищить 16.
Код програми:
lw 0 1 a
lw 0 2 b
lw 0 3 c
lw 0 5 Res
start add 1 2 1
jma 1 3 end
beq 0 0 start
end sw 0 1 Res
halt
a .fill -4
b .fill -4
c .fill 16
Res .fill 0
Результат:
Початковий стан машини:
Кінцевий стан машини:
state:
pc 0
memory:
mem[ 0 ] 8454153
mem[ 1 ] 8519690
mem[ 2 ] 8585227
mem[ 3 ] 8716300
mem[ 4 ] 655361
mem[ 5 ] 55246849
mem[ 6 ] 16842749
mem[ 7 ] 12648460
mem[ 8 ] 25165824
mem[ 9 ] -4
mem[ 10 ] -4
mem[ 11 ] 16
mem[ 12 ] 0
registers:
reg[ 0 ] 0
reg[ 1 ] 0
reg[ 2 ] 0
reg[ 3 ] 0
reg[ 4 ] 0
reg[ 5 ] 0
reg[ 6 ] 0
reg[ 7 ] 0
flags:
CF[ 0 ] 0
end state
state:
pc 9
memory:
mem[ 0 ] 8454153
mem[ 1 ] 8519690
mem[ 2 ] 8585227
mem[ 3 ] 8716300
mem[ 4 ] 655361
mem[ 5 ] 55246849
mem[ 6 ] 16842749
mem[ 7 ] 12648460
mem[ 8 ] 25165824
mem[ 9 ] -4
mem[ 10 ] -4
mem[ 11 ] 16
mem[ 12 ] -20
registers:
reg[ 0 ] 0
reg[ 1 ] -20
reg[ 2 ] -4
reg[ 3 ] 16
reg[ 4 ] 0
reg[ 5 ] 0
reg[ 6 ] 0
reg[ 7 ] 0
flags:
CF[ 0 ] 0
end state
24.11.2018 17:11-
Ділись своїми роботами та отримуй миттєві бонуси!
0%
Оголошення від адміністратора