Máy tính giả lập Xyclotron: gồm bộ nhớ và 3 thanh ghi; bộ nhớ gồm 100 từ, mỗi từ lưu

trữ 1 giá trị gồm 4 chữ số ví du: 0954, 1538,.v.v. truy xuất giá trị bằng cách chỉ mục vị trí
bộ nhớ. Ví dụ: bộ nhớ [3] chứa giá trị được lưu ở vị trí thứ 4 trong bộ nhớ (bắt đầu đếm
từ 0).
3 thanh ghi bao gồm:
một thanh ghi có mục đích chung được gọi là Accumulator (bộ tích lũy)
một thanh ghi thứ cấp để lưu trữ các giá trị tạm thời, được gọi là T
program-counter: lưu trữ vị trí bộ nhớ của lệnh tiếp theo sẽ được thực thi

Xyclotron tuân theo chu trình tìm nạp-giải mã-thực thi để chạy chương trình được lưu
trong bộ nhớ:
Tìm nạp: Máy tính lấy từ bộ nhớ giá trị của từ được lưu trữ tại vị trí được chỉ định bởi bộ
đếm chương trình.
Giải mã: Nó cố gắng diễn giải giá trị dưới dạng lệnh mã máy hợp lệ.
Thực thi: Nếu giải mã thành công, nó sẽ cố gắng thực hiện lệnh và tăng bộ đếm chương
trình (trừ khi lệnh đã sửa đổi rõ ràng bộ đếm chương trình).
Xyclotron có ngôn ngữ mã máy chỉ với 13 lệnh khác nhau. Chúng được mô tả trong bảng
dưới đây:

Mnemonic Opcode Meaning

Add a value to the value stored in the accumulator.

ADD 10 If operand = 0, add the value of T; otherwise add the
value stored in memory location operand.

Subtract a value from the value stored in the

accumulator.
SUB 11
If operand = 0, subtract the value of T; otherwise
subtract the value stored in memory location operand.

Load a value into the accumulator.

LOAD 12 If operand = 0, load the value of T; otherwise load the
value stored in memory location operand.
 Stores the value currently in the accumulator into a
new location.
STORE 13
If operand = 0, store the value in T; otherwise store it
in memory location operand.
INC 20 Increment the accumulator (add 1 to its value).
DEC 21 Decrement the accumulator (subtract 1 from its value).
Print a value to the screen. If operand = 0, print the
OUT 30 value in the accumulator. Otherwise, print the value
stored in memory location operand.
Jump to memory location operand (i.e. set the program
JUMP 40
counter to operand), and continue.
Jump to memory location operand if the accumulator
JUMPPOS 41
value is positive (greater than zero).
Jump to memory location operand if the accumulator
JUMPNEG 42
value is negative (less than zero).
Jump to memory location operand if the accumulator
JUMPZERO 43
value is equal to zero.
HALT 99 Halt program execution (operand is ignored.)
SKIP 00 Do nothing (operand is ignored.)

Khi một từ được lấy từ bộ nhớ, bước giải mã sẽ chia nó thành hai phần bằng nhau. Phần
được biểu thị bằng hai chữ số đầu tiên của từ là mã hoạt động hoặc opcode. Đây là một số
từ 00 đến 99 đại diện cho hướng dẫn cụ thể. Chỉ có 13 mã opcode như trong bảng là hợp
lệ. Hai chữ số cuối cùng biểu thị toán hạng, tức là giá trị mà lệnh sẽ được thực hiện trên
đó.

Ví dụ: nếu vị trí hiện tại trong bộ nhớ chứa từ 1109 thì nó được chia thành opcode = 11
và toán hạng = 09. Vì 11 tương ứng với lệnh SUB nên mục đích của lệnh sẽ là sửa đổi giá
trị hiện tại trong bộ tích lũy, bằng cách trừ đi giá trị được lưu ở vị trí 9 trong bộ nhớ. Vì
vậy, nếu bộ tích lũy chứa giá trị 7 và vị trí bộ nhớ 0009 chứa giá trị 12 thì kết quả của
lệnh là bộ tích lũy sẽ chứa giá trị -5.

Lưu ý rằng T và bộ tích lũy có thể chứa các giá trị âm; tuy nhiên, vị trí bộ nhớ chỉ có thể
lưu trữ số 0 hoặc số nguyên dương.
Cho sẵn Main.cpp và Xyclotron.h
Main.cpp:
#include "Xyclotron.h"
#include <cstring>
int main(int argc, char *argv[]) {
bool trace = (argc > 1 && !strcmp(argv[1], "-trace"));
bool read_and_dump = (argc > 1 && !strcmp(argv[1], "-dump"));
Xyclotron x (trace);
x.read_program();
if (read_and_dump) {
x.memory_dump();
}
x.run_program();
return 0;
}

Xyclotron.h:
#ifndef PRAC3_XYCLOTRON_H
#define PRAC3_XYCLOTRON_H
#include <string>
class Xyclotron {
public:
Xyclotron(bool trace=false);
static std::string trace_format(int command, int accumulator, int
T, int out=-
1) {
return "CMD:" + std::to_string(command)
+ " ACC:" + std::to_string(accumulator)
+ " T:" + std::to_string(T)
+ (out == -1 ? "" : std::to_string(out));
}
int get_accumulator();
int get_T();
void memory_dump();
void read_program();
void run_program();
private:
// INSTRUCTION SET OPCODES
static const int ADD = 10;
static const int SUB = 11;
static const int LOAD = 12;
static const int STORE = 13;
static const int INC = 20;
static const int DEC = 21;
static const int CLEAR = 22;
static const int OUT = 30;
static const int JUMP = 40;
static const int JUMPPOS = 41;
static const int JUMPNEG = 42;
static const int JUMPZERO = 43;
static const int HALT = 99;
static const int SKIP = 0; // 00 - not really used
static std::string opcode_to_mnemonic(int opcode) {
switch(opcode){
case ADD: return "ADD"; break;
case SUB: return "SUB"; break;
case LOAD: return "LOAD"; break;
case STORE: return "STORE"; break;
case INC: return "INC"; break;
case DEC: return "DEC"; break;
case CLEAR: return "CLEAR"; break;
case OUT: return "OUT"; break;
case JUMP: return "JUMP"; break;
case JUMPPOS: return "JUMPPOS"; break;
case JUMPNEG: return "JUMPNEG"; break;
case JUMPZERO: return "JUMPZERO"; break;
case HALT: return "HALT"; break;
case SKIP: return "SKIP"; break;
}
}
static std::string formatted_trace(int mem_address, int opcode, int
operand,
int accumulator_value, int T_value) {
return ">> " + std::to_string(mem_address) + ": " +
std::to_string(opcode) + " [" + opcode_to_mnemonic(opcode) + "] " +
std::to_string(operand) +
"; ACC=" + std::to_string(accumulator_value) +
", T=" + std::to_string(T_value) + " <<";
}
// REGISTERS
int accumulator = 0; // General-purpose computer register
int T = 0; // Register for temporary memory
int program_counter = 0;// the line in the program to execute next
// INTERNAL STORAGE IN THE COMPUTER (how should these arrays be
initialised?)
int memory[100]; // input memory
bool trace = false;
};
#endif //PRAC3_XYCLOTRON_H

Lưu ý: không được thay đổi main.cpp

tất cả các chương trình mã máy Xyclotron đều bắt đầu chạy tại lệnh được lưu ở vị trí thứ
2 trong bộ nhớ, tức là tại vị trí bộ nhớ 1
Nhiệm vụ:
viết chương trình Xyclotron.cpp và thêm phương thức cho Xyclotron.h để thực hiện
chu trình tìm nạp-giải mã-thực thi của Xyclotron. Máy tính mô phỏng sẽ đọc
chương trình từ cin (kết thúc bằng EOF).
Đồng thời triển khai bộ nhớ_dump(), in ra kết xuất các giá trị hiện tại trong bộ nhớ
khi đối số dòng lệnh -dump được truyền vào.
Thực hiện theo dõi: khi đối số dòng lệnh -trace được truyền vào, máy tính sẽ in dấu
vết của dòng hiện tại ra màn hình. Định dạng được đưa ra bởi formatted_trace().
Sau khi in dấu vết, lệnh sẽ được thực hiện (bao gồm mọi đầu ra). Việc theo dõi có
thể giúp bạn gỡ lỗi chương trình của mình.

Cho các input sau:

(Chương trình prog1a.xyc):
1205
1006
3000
9900
0081
1099
Ví dụ: Chương trình prog1a.xyc l Tải xuống prog1a.xyc tải số ở vị trí 05 (tức là dòng 5
trong chương trình) vào Accumulator. Tiếp theo, nó thêm số ở vị trí 06, in giá trị tích lũy
(hiện là 1180) ra màn hình và kết thúc. Lưu ý rằng chương trình không tiếp tục vượt quá
câu lệnh HALT ở dòng 4.

(Chương trình prog1b-1.xyc):

1206
1107
1107
3000
9900
0065
0020
Ví dụ: Chương trình prog1b-1.xyc Tải xuống prog1b-1.xyc lưu X ở vị trí 6 và Y ở vị trí
7, đồng thời in ra giá trị của X - 2*Y.

(Chương trình prog2a.xyc)

4007
0013
0025
0037
0004
0005
1202
1003
1104
4314
1205
3000
9900
1206
3000
9900
Ví dụ: Chương trình prog2a.xyc Tải xuống prog2a.xycstores X ở vị trí 2, Y ở vị trí 3 và Z
ở vị trí 4, và M1 ở vị trí 5 và M2 ở vị trí 6. Nếu X+Y=Z, nó xuất ra M1, nếu không nó
xuất ra M2 .

(Chương trình prog2b.xyc):

4010
0057
0057
0014
0015
0016
0000
0000
0000
1202
1103
4115
4217
4319
3004
9900
3005
9900
3006
9900
Ví dụ: Chương trình prog2b.xyc Tải xuống prog2b.xycstores X ở vị trí 2, Y ở vị trí 3, và
các thông báo từ M1 đến M3 ở vị trí từ 4 đến 6. Nếu X = Y, nó sẽ in M3. Nếu X > Y, nó
in ra M1. Nếu X < Y, nó in M2.

Bài nâng cao:

viết loop.xyc, một chương trình chứa hai số X và Y, được lưu trữ trong các vị trí bộ nhớ.
Chương trình cần lặp X lần, mỗi lần in Y. Tức là nếu X = 4, Y = 3 thì đầu ra là
3
3
3
3

viết prime.xyc. Chương trình này lưu trữ một số X trong bộ nhớ và in ra tất cả các số
nguyên tố theo thứ tự nhỏ hơn hoặc bằng X.