rushilwiz/comp211
1
0
Fork 0
mirror of https://github.com/Rushilwiz/comp211.git synced 2025-04-03 02:40:16 -04:00
Code Issues Actions Packages Projects Releases Wiki Activity

uploaded lab 2-5

Browse Source
This commit is contained in:
Rushil Umaretiya 2024-04-10 21:03:17 -04:00
parent 196836f0b6
commit 365fa3bd5b
No known key found for this signature in database
GPG Key ID: 4E8FAF9C926AF959
45 changed files with 3354 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -1 +1,2 @@
*lock*
.vscode/*

BIN
exam_env/exam Executable file
View File

Binary file not shown.

20
exam_env/exam.c Normal file
View File

@ -0,0 +1,20 @@
#include <stdio.h>
#include <stdlib.h>
int main() {
short a = -3;
int b = (int) a;
unsigned short c = (unsigned short) a;
unsigned int d = (unsigned int) c;
// The "h" modifier here tells printf that
// a is a short. Otherwise the value would
// be treated like an int.
printf("%hx\n", a);
printf("%x\n", b);
printf("%hx\n", c);
printf("%x\n", d);
return EXIT_SUCCESS;
}

34
lab-00/0-hello-world/hello.s Normal file
View File

@ -0,0 +1,34 @@
.file "hello.c"
.text
.section .rodata
.LC0:
.string "Hello, world."
.LC1:
.string "Welcome to C!"
.text
.globl main
.type main, @function
main:
.LFB6:
.cfi_startproc
pushq %rbp
.cfi_def_cfa_offset 16
.cfi_offset 6, -16
movq %rsp, %rbp
.cfi_def_cfa_register 6
leaq .LC0(%rip), %rax
movq %rax, %rdi
call puts@PLT
leaq .LC1(%rip), %rax
movq %rax, %rdi
movl $0, %eax
call printf@PLT
movl $0, %eax
popq %rbp
.cfi_def_cfa 7, 8
ret
.cfi_endproc
.LFE6:
.size main, .-main
.ident "GCC: (Debian 12.2.0-14) 12.2.0"
.section .note.GNU-stack,"",@progbits

14
lab-02/.gitignore vendored Normal file
View File

@ -0,0 +1,14 @@
# Build files
*.o
*.out
signed
twos
negate2s
f32
.vscode
# macOS
.DS_Store
# IDEif (i >= 0)
.idea

49
lab-02/Makefile Normal file
View File

@ -0,0 +1,49 @@
SHELL=/bin/bash
CC=gcc
CFLAGS=-Wall -Werror -g
DIFF_FLAGS=--ignore-blank-lines
all: signed twos negate2s f32
test: test_signed test_twos test_negate2s test_f32
signed: signed.c
$(CC) $(CFLAGS) signed.c -o signed
twos: twos.c
$(CC) $(CFLAGS) twos.c -o twos
negate2s: negate2s.c
$(CC) $(CFLAGS) negate2s.c -o negate2s
f32: f32.c
# -lm is necessary if using `pow` from <math.h>, as mentioned in README
$(CC) $(CFLAGS) f32.c -lm -o f32
test_signed: signed
diff $(DIFF_FLAGS) <(echo 0000000011010011) <(./signed +211)
diff $(DIFF_FLAGS) <(echo 1000000011010011) <(./signed -211)
diff $(DIFF_FLAGS) <(echo not possible) <(./signed +100000)
diff $(DIFF_FLAGS) <(echo 0000000000000000) <(./signed +0)
# You probably have to hardcode for this case because atoi("-0") is just 0
diff $(DIFF_FLAGS) <(echo 1000000000000000) <(./signed -0)
test_twos: twos
diff $(DIFF_FLAGS) <(echo 0000000011010011) <(./twos +211)
diff $(DIFF_FLAGS) <(echo 1111111100101101) <(./twos -211)
diff $(DIFF_FLAGS) <(echo not possible) <(./twos +100000)
test_negate2s: negate2s
diff $(DIFF_FLAGS) <(echo 11111111111111111111111100101101) <(./negate2s 00000000000000000000000011010011)
test_f32: f32
diff $(DIFF_FLAGS) <(echo 1.0000) <(./f32 00111111100000000000000000000000)
diff $(DIFF_FLAGS) <(echo -1.0000) <(./f32 10111111100000000000000000000000)
diff $(DIFF_FLAGS) <(echo 0.1375) <(./f32 00111110000011001100110011001101)
clean:
# Without 2> /dev/null, if these files didn't exist, rm would print "cannot remove... No such file..." to stderr
# 2> /dev/null redirects stderr (file descriptor 2) to /dev/null
# /dev/null is a place for junk, and it discards anything written to it
# || true makes the return code 0 unconditionally (even if the files don't exist so rm returns 1)
rm signed twos negate2s f32 2> /dev/null || true

169
lab-02/README.md Normal file
View File

@ -0,0 +1,169 @@
<!-- omit in toc -->
# Lab 2
In this lab, you will implement several methods of representing numbers (integer and real) in binary.
<details open>
<summary>Contents</summary>
- [Pre-lab knowledge](#pre-lab-knowledge)
- [Number representation](#number-representation)
- [I/O](#io)
- [Makefile](#makefile)
- [Autograder](#autograder)
- [Part 1. Signed integers](#part-1-signed-integers)
- [Part 2. Two's complement](#part-2-twos-complement)
- [Part 3. Negation of two's complement](#part-3-negation-of-twos-complement)
- [Part 4. IEEE754 float 32](#part-4-ieee754-float-32)
- [Submit your assignment](#submit-your-assignment)
</details>
## Pre-lab knowledge
### Number representation
To review number representation, see the lecture about [information encoding, number systems, and integer representation and floating point representation](https://uncch.instructure.com/users/9947/files/6721199?verifier=oUYyOKAiD0sBCNKBB8XHXrx67hqTg3L8nBfIlSKU&wrap=1) ([video](https://uncch.hosted.panopto.com/Panopto/Pages/Sessions/List.aspx?folderID=bb31c498-8a66-4d21-92aa-b0f100e6ddda)).
Although lecture material should suffice, you may also refer to the following sources:
* [Supplement: Binary Math and Signed Representations](https://uncch.instructure.com/users/9947/files/4534602?verifier=V0fp04VZnOi0ytrumtvCTbL2Xnz1zR5AUmj2H2S3&wrap=1)
* Sections 2.1, 2.2, and 2.3 of [Computer Systems: A Programmer's Perspective](https://uncch.instructure.com/users/9947/files/4526297?verifier=GsaGSp6QkNQvZGMOCCiuAT4eyRWq70bxIKOgxjZr&wrap=1).
### I/O
Similarly, you may refer to the following sources for information about I/O that will be needed:
* Section 5.10 Command-line Arguments in [The C Programming Language](https://uncch.instructure.com/users/9947/files/4526296?verifier=bzWbUsKclOVAAJ7MfuwOyS5v8DDILep0R7HtGh7t&wrap=1)
* Section 7.2 Formatted Output - Printf in The C Programming Language
In particular, you should not use `getchar`, `fgets`, or `scanf`; instead, you should work with `argv`.
### Makefile
See the file [Makefile](Makefile) in your repository. Makefiles are used by the command `make`, which is a build automation tool.
To try it out, run `make` from the root of your repo. You'll see some output, and you'll also notice that 4 new executables were created. This command automates the `gcc` steps that we would normally repeatedly execute!
We will also use this Makefile to run tests, both locally and in the autograder, so now we'll discuss its contents.
First, see the target called `signed`:
```make
signed: signed.c
$(CC) $(CFLAGS) signed.c -o signed
```
The second line is exactly what we would write to compile `signed.c` into the executable `signed`. `CC` and `CFLAGS` are variables defined at the top of the file.
The first line follows the syntax `target: dependencies`. Because `signed` is the target, we can run `make signed` to perform only the action above (i.e., compile `signed.c`). Try it, and you should see the output
```text
learncli$ make signed
make: 'signed' is up to date.
```
Because we specified that the target `signed` depends on `signed.c`, `make` knows it doesn't need to do anything for `signed` since we had already run that target when we previously ran `make`, and we didn't modify `signed.c` since then. However, if you modify `signed.c` (e.g., change `EXIT_SUCCESS` to `EXIT_FAILURE`), then `make signed` will recompile `signed.c`.
You'll also notice the target `all` at the top, which depends on `signed`, `twos`, `negate2s`, and `f32`. When you ran `make` without arguments, `all` ran because it is the first target.
Lastly, the `test` target depends on `test_signed`, `test_twos`, `test_negate2s`, and `testf32`. Thus, you can run `make test_signed` to run the tests for `signed.c` or `make test` to run local tests for all files.
For example, if you run `make test_signed` now (without implementing `signed.c`), you should see
```text
learncli$ make test_signed
gcc -Wall -Werror -g signed.c -o signed
diff --ignore-blank-lines <(echo 0000000011010011) <(./signed +211)
1d0
< 0000000011010011
make: *** [Makefile:24: test_signed] Error 1
learncli$ echo $? # print exit status of previous command
2
```
When the program is done and works properly, you should instead see
```text
learncli$ make test_signed
gcc -Wall -Werror -g signed.c -o signed
diff --ignore-blank-lines <(echo 0000000011010011) <(./signed +211)
diff --ignore-blank-lines <(echo 1000000011010011) <(./signed -211)
diff --ignore-blank-lines <(echo not possible) <(./signed +100000)
diff --ignore-blank-lines <(echo 0000000000000000) <(./signed +0)
diff --ignore-blank-lines <(echo 1000000000000000) <(./signed -0)
learncli$ echo $?
0
```
The Makefile tests are comprised of `diff` commands using the `<()` operator, which you should be familiar with from the previous lab. So, we will not specify expected input and output for your programs in this writeup since that information is already in the Makefile.
### Autograder
The autograder will run the tests in our Makefile and, in addition, some tests using random inputs.
Note that all programs for this lab expect input from command-line arguments, **not standard input**, unlike the previous lab. Additionally, assume that any random inputs from the autograder are always syntactically valid (i.e., follow the examples in the Makefile), so you do not need to worry about syntactically invalid inputs. However, as shown in the tests for `signed.c` and `twos.c`, if a number cannot be represented, print `not possible`.
## Part 1. Signed integers
In `signed.c`, write a program that takes a base-10 integer preceded by a plus or minus sign as a command-line argument and outputs a 16-bit string of 1's and 0's corresponding to the integer's 16-bit signed magnitude representation. For example,
```text
learncli$ ./signed +211
0000000011010011
learncli$ ./signed +100000
not possible
```
For more I/O examples, see the [Makefile](Makefile). To run local tests, see the section [above](#makefile).
Use the `stdlib.h` function [`atoi`](https://cplusplus.com/reference/cstdlib/atoi/) [^atoi] to convert a string to integer. The syntax of inputs in the test cases matches the syntax that `atoi` expects. Specifically, `atoi` accepts an optional initial `+` or `-`, followed by as many base-10 digits as possible.
[^atoi]: `atoi` is short for "ASCII to integer".
Note that +0 and -0 have different signed magnitude representations, so your program should output the correct representations for these two inputs. Is this property of signed magnitude desirable or undesirable?
## Part 2. Two's complement
In `twos.c`, write a program that takes a base-10 integer preceded by a plus or minus sign as a command-line argument and outputs the 16-bit string of 1's and 0's corresponding to the integer's 16-bit two's complement representation. See I/O examples in the Makefile.
Note that 0 has only one representation in two's complement, unlike signed magnitude.
## Part 3. Negation of two's complement
In `negate2s.c`, write a program that takes **32-bit** two's complement representation of an integer as a command-line argument and outputs a 32-bit two's complement bitstring corresponding to the negated version of the number. See I/O examples in the Makefile.
## Part 4. IEEE754 float 32
In `f32.c`, write a program that takes a **32-bit** IEEE754 representation of a float as a command-line argument and outputs the `float` it represents in base-10. See I/O examples in the Makefile.
To account for floating-point error, when printing the float, use `printf("%.4f\n", float_value)` to print to 4 decimal places. These autograder will check these digits for an exact match.
These libraries should be useful:
* `string.h`
* `argv[1]` is a string. You are now allowed to use `string.h` to make working with strings easier (unlike the previous lab).
* When creating a new string, you must null-terminate it by putting the null terminator `'\0'` in the last position. If you are using a `char[]`, allocate one extra character than what you expect to use. Most string functions will not work correctly if the string is not null-terminated.
* **You do not have to convert the exponent bits to a base-10 integer yourself**. Please use [`strtol`](https://www.tutorialspoint.com/c_standard_library/c_function_strtol.htm) to convert the exponent bits (`const char*`) to `long`. Pass `NULL` as the second argument.
* You may use `strlen` to get the length of a string.
* You may use [`strncpy`](https://www.tutorialspoint.com/c_standard_library/c_function_strncpy.htm) to extract the exponent bits and mantissa bits from the 32-bit string. It can be used similarly to slicing in Python (`str[start:end]`) or Java's `substring(begIndex, endIndex)` method.
* `math.h`
* **Please do not implement exponentiation yourself**. For exponentiation, use `pow`, which takes two `double`s and returns a `double`.
* As done in the Makefile, the program must be compiled with the `-lm` flag to link the math library. For example, `gcc f32.c -lm -o f32`. `-lm` must go after the objects to be linked.
## Submit your assignment
Assignment submissions will be made through [Gradescope](https://www.gradescope.com).
To submit your assignment, you must commit and push your work to this repository using git. You are likely unfamiliar with git at this point, so just follow these steps:
1. Navigate to the base folder of the repository within Docker using the `cd` commmand.
2. Type `git status`. You should see a list of changes that have been made to the repository.
3. Type `git add -A`. This signals that you want to place all modified / new files on the "stage" so that their changes can take effect.
4. Type `git commit -m "Your Message Here"`. This shows that you are "committing" to the changes you put on the stage. Instead of Your Message Here, you should write a meaningful message about what changes you have made.
5. Type `git push`. This takes the commit that was made locally on your machine and "pushes" it to GitHub. Now, when you view this repository on GitHub you should be able to see the changes you've made, namely the addition of your source files!
6. Go to the COMP 211 course in Gradescope and click on the assignment called **Lab 2**.
7. Click on the option to **Submit Assignment** and choose GitHub as the submission method.
8. You should see a list of your public repositories. Select the one named **lab-02-yourname** and submit it.
9. Your assignment should be autograded within a few seconds and you will receive feedback for the autograded portion.
10. If you receive all the points, then you have completed this lab! Otherwise, you are free to keep pushing commits to your GitHub repository and submit for regrading up until the deadline of the lab.

37
lab-02/f32.c Normal file
View File

@ -0,0 +1,37 @@
// PID: 730677144
// I pledge the COMP 211 honor code.
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc, char* argv[]) {
// convert a IEEE 754 single precision floating point number to a 32-bit
// integer
char input[33];
char exponent[9];
char mantissa[24];
strncpy(input, argv[1], 32);
input[32] = '\0';
strncpy(exponent, input + 1, 8);
strncpy(mantissa, input + 9, 23);
int sign = (input[0] == '1') ? -1 : 1;
long int exp = strtol(exponent, NULL, 2) - 127;
float frac = 1.0;
for (int i = 0; i < 23; i++) {
if (mantissa[i] == '1') {
frac += pow(2, -i - 1);
}
}
float result = sign * frac * pow(2, exp);
printf("%.4f\n", result);
}

39
lab-02/negate2s.c Normal file
View File

@ -0,0 +1,39 @@
// PID: 730677144
// I pledge the COMP 211 honor code.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc, char* argv[]) {
char input[33];
char output[33] = {'\0'};
strncpy(input, argv[1], 32);
input[32] = '\0';
for (int i = 0; i < 32; i++)
output[i] = (input[i] == '0') ? '1' : '0';
output[32] = '\0';
if (input[0] == '1') {
int carry = 1;
for (int i = 31; i >= 0 && carry; i--) {
output[i] = (input[i] == '0') ? '1' : '0';
if (input[i] == '0')
carry = 0;
}
} else {
int i = 31;
while (input[i] == '0' && i >= 0) {
output[i] = '0';
i--;
}
output[i] = '1';
}
printf("%s\n", output);
return EXIT_SUCCESS;
}

33
lab-02/signed.c Normal file
View File

@ -0,0 +1,33 @@
// PID: 730677144
// I pledge the COMP 211 honor code.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char* argv[]) {
int num = atoi(argv[1]);
if (num < -32768 || num > 32767) {
printf("not possible\n");
return 0;
}
if (argv[1][0] == '-') {
printf("1");
num = -num;
} else {
printf("0");
}
for (int i = 14; i >= 0; i--) {
if (num >= (1 << i)) {
printf("1");
num -= (1 << i);
} else {
printf("0");
}
}
printf("\n");
return EXIT_SUCCESS;
}

47
lab-02/twos.c Normal file
View File

@ -0,0 +1,47 @@
// PID: 730677144
// I pledge the COMP 211 honor code.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char* argv[]) {
int num = abs(atoi(argv[1]));
char out[17] = "\0";
if (num > 65535) {
printf("not possible\n");
return 0;
}
for (int i = 15; i >= 0; i--) {
if (num >= (1 << i)) {
out[15 - i] = '1';
num -= (1 << i);
} else {
out[15 - i] = '0';
}
}
if (argv[1][0] == '-') {
for (int i = 0; i < 16; i++) {
if (out[i] == '0') {
out[i] = '1';
} else {
out[i] = '0';
}
}
for (int i = 15; i >= 0; i--) {
if (out[i] == '1') {
out[i] = '0';
} else {
out[i] = '1';
break;
}
}
}
printf("%s\n", out);
return EXIT_SUCCESS;
}

11
lab-03/.gitignore vendored Normal file
View File

@ -0,0 +1,11 @@
# Build files
*.o
*.so
*.out
test
# macOS
.DS_Store
# IDE
.idea

44
lab-03/Makefile Normal file
View File

@ -0,0 +1,44 @@
# Do not modify! If you do, your changes will be overwritten during autograding.
CC=gcc
# -c says to not run the linker and output object files (.o)
# We manually link the object files into an executable to save time compiling
# -g includes debugging symbols for gdb
CFLAGS=-c -Wall -Werror -g
SO_FLAGS=-fPIC -shared
# Builds the test executable but does not run
all: test for_autograder
test: bit_utils.o test.o
${CC} bit_utils.o test.o -o test
# This runs the tests
test_all: test_mask test_set test_inverse test_bit_select test_barrel_shift
test_mask: test
./test mask
test_set: test
./test set
test_inverse: test
./test inverse
test_bit_select: test
./test bit_select
test_barrel_shift: test
./test barrel_shift
bit_utils.o: bit_utils.c bit_utils.h
$(CC) $(CFLAGS) bit_utils.c
test.o: test.c
$(CC) $(CFLAGS) test.c
# This will work if bit_utils.o works
for_autograder: bit_utils.o
$(CC) $(SO_FLAGS) -o bit_utils.so bit_utils.o
clean:
-rm -f test *.o *.so

108
lab-03/README.md Normal file
View File

@ -0,0 +1,108 @@
<!-- omit in toc -->
# Lab 3
This lab explores C's bitwise logic and shift operations.
In `bit_utils.c`, implement the functions specified in the header file `bit_utils.h`. Don't add additional include statements in `bit_utils.c`. By including `bit_utils.h`, your `bit_utils.c` will have access to all the necessary libraries.
<details open>
<summary>Contents</summary>
- [Pre-lab knowledge](#pre-lab-knowledge)
- [Background reading](#background-reading)
- [Vim tips](#vim-tips)
- [Testing](#testing)
- [Debugging with GDB](#debugging-with-gdb)
- [Integer representation](#integer-representation)
- [Part 1: Bitwise operators](#part-1-bitwise-operators)
- [Part 2: Shift operator](#part-2-shift-operator)
- [bit\_select](#bit_select)
- [barrel\_shift](#barrel_shift)
- [Submit your assignment](#submit-your-assignment)
</details>
## Pre-lab knowledge
To review bitwise operators and shift operations, see the lecture about [Integer Overflow and Casting, Bitwise Operations (logic and shift)](https://uncch.instructure.com/users/9947/files/6721201?verifier=ul42p7etinDLvO14yQ2qIxY8zSFXAyQS0T4o0ch5&wrap=1) ([videos](https://uncch.hosted.panopto.com/Panopto/Pages/Sessions/List.aspx#folderID=%225592a969-2ec3-485d-b26e-b0f100e6dde6%22)).
### Background reading
- [C Programming Language](https://uncch.instructure.com/users/9947/files/4526296?verifier=bzWbUsKclOVAAJ7MfuwOyS5v8DDILep0R7HtGh7t&wrap=1) Section 2.9 - Bitwise Operators
### Vim tips
If you have decided to stick with Vim, you are cooler and have a greater potential power level than everyone that isn't. Hopefully, you have gone over `vimtutor` a few times and are comfortable navigating with Vim, and maybe you're familiar enough to edit as fast as you would with a regular text editor.
With more practice, you can use Vim's powerful features to easily exceed your editing speed in a regular text editor. For Vim tips, see [Editors (Vim)](https://missing.csail.mit.edu/2020/editors/) (you may have to refresh the page) from the MIT Missing Semester course (their shell article was linked in a previous lab). We would recommend reading the article and/or watching the video and **practicing** the new Vim features that are shown. In particular, view [37:33](https://youtu.be/a6Q8Na575qc?t=2253) to 44:38 for a demo of advanced Vim features.
We recommend exercise 5, reproduced here:
> Use Vim for all your text editing for the next month. Whenever something seems inefficient, or when you think “there must be a better way”, try Googling it, there probably is.
<!-- Specifically, note that most IDE's have Vim plugins, such as [VSCodeVim](https://marketplace.visualstudio.com/items?itemName=vscodevim.vim) and [IdeaVim](https://www.jetbrains.com/help/idea/using-product-as-the-vim-editor.html) (IntelliJ). -->
Lastly, if you intend to customize Vim via `.vimrc`, note that changes you make to `.vimrc` in the container will not persist when you exit the container. So, if you would like to do so, you will need to install Vim locally (not in the container).
### Testing
`bit_utils.c` is a mini library rather than a program. `test.c` is the runner program that is used to test the functions. `test.c` defines a `main` function, so `bit_utils.c` cannot define a `main` function (e.g., to test the functions).
To test your functions, you may use the provided tests in `test.c`. This should be done with the [Makefile](Makefile), similar to the previous lab. Specifically, there are targets `test_mask`, `test_set`, `test_inverse`, `test_bit_select`, and `test_barrel_shift`. For example, to run the tests for the `mask` function, run `make test_mask`. To run tests for all functions, run `make test_all`. Similar to the previous lab, since the test cases are given in `test.c`, we will not specify expected input and output for each function in this writeup since that information is in `test.c`.
Finally, you may write additional tests in `test.c`, if you wish. However, all changes you make to `test.c` will be overwritten when submitting.
### Debugging with GDB
GDB is a command line debugger for C. Hopefully, you have already encountered debuggers for other languages, such as Python or Java, and have seen that they offer greater utility than debugging just with print statements, such as the ability to set breakpoints, run the program until the next breakpoint, and examine program state (variables and expressions) at any point in the program easily. The page [GDB and Debugging](https://web.stanford.edu/class/archive/cs/cs107/cs107.1194/resources/gdb) provides a brief introduction to GDB, and we strongly recommend using GDB for debugging in this lab and future labs. The section [gdb Commands Reference](https://web.stanford.edu/class/archive/cs/cs107/cs107.1194/resources/gdb#gdb-commands-reference) is particularly useful.
To use GDB, the program has to be compiled with `-g` to include debugging information. This is done in all of our Makefiles.
### Integer representation
Integers in C can be declared as decimal, hexadecimal or octal numbers. The following three lines of code are equivalent:
``` c
int n = 0x05; int i = 0xa2; // hex
int n = 5; int i = 162; // decimal
int n = 05; int i = 0242; // octal
```
The underlying representation in binary for `162` and `0xa2` is the same. You may use the `"%d"`, `"%x"`, and `"%o"` format specifiers to print integers in decimal, hex, or octal format, respectively.
In this lab, you will probably want to use `"%x"` when debugging because we want to look directly at the bit representation (see the test cases in `test.c`), not the decimal representation. We could display in binary format, but hex is more concise and readable because each hexit corresponds to four bits. For example, `0x7 = 0b0111`, `0x07 = 0b00000111`, `0xE = 0b1110`, and `0xE7 = 0b11100111`. It is usually easier to read the hex representation than the binary representation.
Lastly, in this assignment, all functions operate on and return `unsigned int`s, which are 32 bits or 4 bytes on our machines. This is to prevent arithmetic shifting, which does not make sense in the context of this lab. If a number can be represented in fewer than 32 bits, then it is zero-padded to 32 bits. For example, `0xF` is `0x0000000F`.
## Part 1: Bitwise operators
In `bit_utils.c`, write 3 functions: `mask`, `set`, and `inverse`. These functions each take two integer parameters: a number to be operated on and the bits that will be masked, set, or inversed. Each function should return the number with the applied mask, set, or inverse.
For examples, see [`test.c`](test.c). For each function, the first test is basic and should be easily understandable, and the rest of the tests are more verbose.
These functions should each take only one or two lines of code.
## Part 2: Shift operator
### bit_select
Write a function called `bit_select` that takes three integer parameters: a number, the most significant bit to select, and the least significant. The function should return the bits between the starting bit and the ending bit of the number (including the starting and the ending bit).
For examples, see `test.c`. The first 3 tests are basic, and the rest of the tests are more verbose.
Remember the difference between shift right logical and shift right arithmetic. C has only one right shift operator `>>`. When the left operand is `unsigned`, as in this lab, a logical shift will be performed. Otherwise, when the left operand is signed, most machines will perform an arithmetic shift.
### barrel_shift
Write a function called `barrel_shift` that takes two integer parameters: a number and a shift amount (shamt). The function should return the value of the number circularly shifted to the right by shamt bits (i.e., the bits that are shifted out of the right end are put back in at the left end).
`barrel_shift` examples are provided in `test.c`.
## Submit your assignment
1. Use git to push your finished code to this GitHub repository.
2. Go to the COMP 211 course in Gradescope and click on the assignment called **Lab 3**.
3. Click on the option to **Submit Assignment** and choose GitHub as the submission method.
4. You should see a list of your public repositories. Select the one named **lab-03-yourname** and submit it.
5. Your assignment should be autograded within a few seconds and you will receive feedback for the autograded portion.
6. If you receive all the points, then you have completed this lab! Otherwise, you are free to keep pushing commits to your GitHub repository and submit for regrading up until the deadline of the lab.

46
lab-03/bit_utils.c Normal file
View File

@ -0,0 +1,46 @@
// PID: 730677144
// I pledge the COMP 211 honor code.
/**
* DO NOT define a main function in this file!
* This file is intended to be a library file, so a main function here
* will conflict with the main function in test.c (our "runner" file)
* To test your functions, write tests in test.c
*/
#include "bit_utils.h"
unsigned int mask(unsigned int num, unsigned int bits) {
return num & bits;
}
unsigned int set(unsigned int num, unsigned int bits) {
return num | bits;
}
unsigned int inverse(unsigned int num, unsigned int bits) {
return num ^ bits;
}
unsigned int bit_select(unsigned int num,
unsigned int startbit,
unsigned int endbit) {
unsigned int shifted = num >> endbit;
unsigned int bit_count = startbit - endbit + 1;
unsigned int mask = (1 << bit_count) - 1;
return shifted & mask;
}
unsigned int barrel_shift(unsigned int num, unsigned int shamt) {
const unsigned int bit_width = sizeof(unsigned int) * 8;
shamt %= bit_width;
if (shamt == 0) {
return num;
}
unsigned int right_part = num >> shamt;
unsigned int left_part = num << (bit_width - shamt);
return right_part | left_part;
}

30
lab-03/bit_utils.h Normal file
View File

@ -0,0 +1,30 @@
// Do not edit this header file!
#include "assert.h"
#include "stdbool.h"
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#define SIZE sizeof(unsigned int) * 8
// Returns num after mask has been applied.
unsigned int mask(unsigned int num, unsigned int bits);
// Returns num after bits have been set.
unsigned int set(unsigned int num, unsigned int bits);
// Returns num after bits have been inversed.
unsigned int inverse(unsigned int num, unsigned int bits);
// Returns the bits in the number from startbit to
// end bit (including startbit and endbit);
unsigned int bit_select(unsigned int num,
unsigned int startbit,
unsigned int endbit);
// Returns value of num circularly shifted to the right by
// shamt (shift amount) positions. The bits that are shifted
// out of the right end are put back in at the left end.
// For example, barrel_shift(0x00F0FFFF, 16) is 0xFFFF00F0
unsigned int barrel_shift(unsigned int num, unsigned int shamt);

49
lab-03/test.c Normal file
View File

@ -0,0 +1,49 @@
/**
* Test/runner file for bit_utils.c
* Run the tests here with `make test_all`, `make test_mask`, etc.
* This file is not meant to be run directly
*
* You may write tests and debug here, but note when submitting, all
* changes you make will not be kept. So, you may add tests, but you should
* not remove any.
* To see the hex representation of an int, use format specifier %x
*/
#include "bit_utils.h"
int main(int argc, char* argv[]) {
if (argc < 2) {
fprintf(stderr,
"test.c requires at least one argument to select the function "
"to test\n");
return EXIT_FAILURE;
}
char* fun_name = argv[1];
if (strcmp("mask", fun_name) == 0) {
assert(mask(0x00F7, 0x000F) == 0x0007);
assert(mask(0x07e081aa, 0xF0FF) == 0x80aa);
assert(mask(0x07e081aa, 0xFFFFFFFF) == 0x7e081aa);
} else if (strcmp("set", fun_name) == 0) {
assert(set(0x00F7, 0x000F) == 0x00FF);
assert(set(0xf70000aa, 0x0abcF0) == 0xf70abcfa);
assert(set(0xdeadbeef, 0x00000000) == 0xdeadbeef);
} else if (strcmp("inverse", fun_name) == 0) {
assert(inverse(0x00F7, 0x000F) == 0x00F8);
assert(inverse(0xf73123aa, 0xc0FFF0) == 0xf7f1dc5a);
assert(inverse(0xf73123aa, 0x00000000) == 0xf73123aa);
} else if (strcmp("bit_select", fun_name) == 0) {
assert(bit_select(0xE7E7, 3, 0) == 0x7);
assert(bit_select(0xE7E7, 7, 0) == 0xE7);
assert(bit_select(0xE7E7, 6, 1) == 0x33);
assert(bit_select(0x07654321, 7, 4) == 2);
assert(bit_select(0x00F0, 6, 4) == 7);
assert(bit_select(0xF, 3, 3) == 1);
assert(bit_select(0xF1111111, 31, 31) == 1);
} else if (strcmp("barrel_shift", fun_name) == 0) {
assert(barrel_shift(0x00F0FFFF, 16) == 0xFFFF00F0);
assert(barrel_shift(0xdeadbeef, 12) == 0xeefdeadb);
} else {
fprintf(stderr, "function name invalid\n");
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}

10
lab-04/.gitignore vendored Normal file
View File

@ -0,0 +1,10 @@
# Build files
*.o
main
# macOS
.DS_Store
# IDE
.idea
.vscode

23
lab-04/Makefile Normal file
View File

@ -0,0 +1,23 @@
CC=gcc
CFLAGS=-c -Wall -Werror -g
all: lab04
lab04: bit_utils.o instructions.o lab04.o
${CC} $^ -o lab04
bit_utils.o: bit_utils.c bit_utils.h
$(CC) $(CFLAGS) bit_utils.c
instructions.o: instructions.c instructions.h bit_utils.h
$(CC) $(CFLAGS) instructions.c
lab04.o: lab04.c instructions.h
$(CC) $(CFLAGS) lab04.c
run: lab04
./lab04
clean:
rm -f lab04 *.o

189
lab-04/README.md Normal file
View File

@ -0,0 +1,189 @@
<!-- omit in toc-->
# Lab 4
In this lab, you'll gain experience working with MIPS instructions by coding a MIPS VM/simulator. Your simulator will
1. convert an integer value into a 32-bit machine (i.e., binary) instruction,
2. determine the type of instruction (R or I),
3. identify the field values (i.e., opcode, rs, rt, rd, sa, func, immediate, etc.), and
4. execute the instruction using a simulated set of registers.
In particular, this lab has four goals:
In this lab, you will apply the `bit_select` function in Lab 3 (the code is given here, in case you need it) to identify the fields in a binary instruction. You will develop a program that closely simulates a real problem and gain experience with C structs, enums, pointers, and `malloc`.
<details open>
<summary>Contents</summary>
- [Lab 4](#lab-4)
- [Pre-lab knowledge](#pre-lab-knowledge)
- [Background reading](#background-reading)
- [Fixed-width integer types](#fixed-width-integer-types)
- [Lab structure](#lab-structure)
- [Part 0](#part-0)
- [Part 1](#part-1)
- [Part 2](#part-2)
- [Examples/testing](#examplestesting)
- [Submit your assignment](#submit-your-assignment)
</details>
## Pre-lab knowledge
### Background reading
* [MIPS cheat sheet](https://uncch.instructure.com/users/9947/files/4534610?verifier=0lJburrtzSqIT791v3YyAlhY3ZBq0MykyBPR1nY6&wrap=1) and other [reference material](https://inst.eecs.berkeley.edu/~cs61c/resources/MIPS_help.html)
* [MIPS Instruction Set Architecture lecture slides](https://uncch.instructure.com/users/9947/files/5281339?verifier=TFMoH6zJsSK35Vd4cCoxOXtTsHnUk9duDuBXABCj&wrap=1) (pg. 8)
The MIPS cheat sheet and lecture slides will be invaluable for this lab, so please be sure to understand those.
### Fixed-width integer types
Throughout the lab, you will see `uint8_t`, `uint16_t`, or `uint32_t` being used as types. These are unsigned data types that are used to represent an integer in an explicit number of `N` bits.
* `uint8_t` represents an `unsigned char` with a size of 8 bits.
* `uint16_t` represents an `unsigned short` with a size of 16 bits.
* `uint32_t` represents an `unsigned int` with a size of 32 bits.
We choose not to use `unsigned char`, `unsigned short`, and `unsigned int` because those are not guaranteed to be 8, 16, and 32 bits on every system.
The values of these types range from `0` to <code>2<sup>N</sup> - 1</code> since they are unsigned. You can read more about these types in this [article](https://www.badprog.com/c-type-what-are-uint8-t-uint16-t-uint32-t-and-uint64-t) or this [manual](https://www.gnu.org/software/libc/manual/html_node/Integers.html).
## Lab structure
```text
.
├── Makefile
├── README.md
├── bit_utils.c - Do not modify (functions from previous lab).
├── bit_utils.h - Do not modify (from previous lab).
├── instructions.c - Contains functions to be implemented in Part 1.
├── instructions.h - Do not modify and please read carefully comments (important definitions and information).
└── lab04.c - Contains functions to be implemented in Part 2.
```
There are comments in the `lab04.c` and `instructions.c` source files as well as in the `instructions.h` header file. Read the comments carefully, as they provide information needed to complete this assignment.
## Part 0
Take a look through each source file and read the comments to have a better understanding of the assignment and the functions you will need to implement.
## Part 1
In this part, you will edit `instructions.c`.
First, implement `get_type_of_instruction`. This function determines the instruction type given an unsigned 32-bit integer by returning an `instruction_type` enum value. For example, if the input is the following 32-bit integer:
```text
00000001000000110001000000100010
```
the function should be able to recognize it as an R-type instruction and return `R_TYPE`. Although J-type instructions also exist in MIPS, you need only distinguish between R-type or I-type in this lab.
Then, implement `create_r_instruction`, `create_i_instruction`, which serve as "constructors" for the `r_instruction` and `i_instruction` structs, which are defined as follows in `instructions.h`:
```c
typedef struct {
uint8_t rs;
uint8_t rt;
uint8_t rd;
uint8_t shamt;
uint8_t func;
} r_instruction;
typedef struct {
uint8_t opcode;
uint8_t rs;
uint8_t rt;
uint16_t immediate;
} i_instruction;
```
`create_r_instruction` and `create_i_instruction` are given the instruction as a 32-bit integer and return a pointer to a `malloc`'d `r_instruction`/`i_instruction` with all fields initialized.
In the next part of this lab, these structures will be used for execution.
To complete this part, reference the top left of the MIPS cheat sheet, which details the position of the fields that each instruction type has:
<p align="center">
<img src="https://i.imgur.com/MmoOTgo.png">
</p>
<p align="center"><em>MIPS instruction format</em></p>
`instructions.h` has several constants that you should use to implement these functions. Specifically, once you have identified whether the instruction is R-type or I-type, you need only extract the bits at the correct positions to initialize the instruction struct. For example, bits 5-0 are the funct bits for an R-type instruction, so the constants `FUNC_START_BIT` and `FUNC_END_BIT` are defined as 5 and 0 and given in `instructions.h`.
## Part 2
In `lab04.c`, implement `execute_r_instruction` and `execute_i_instruction`. `execute_r_instruction` accepts a pointer to an `r_instruction`, while `execute_i_instruction` accepts a pointer to an `i_instruction`. Each function first determines the specific instruction to execute (e.g., if R-type, is the instruction `add`, `sub`, etc.) and then executes it.
Each instruction modifies a register, so update the `registers` global array variable as appropriate. For example, for the MIPS instruction
```asm
and $4, $1, $2
```
Register 4 would be updated with the contents of the bitwise AND of register #1 and register #2, as follows:
```c
registers[4] = registers[1] & registers[2];
```
The following MIPS instructions need to be implemented: `sll`, `sra`, `add`, `sub`, `and`, `or`, `nor`, `addi`, `andi`, `ori`.
**Note**: There are some nuances in MIPS architecture that we will ignore in this lab. For example, `$0`/`$zero` (the "zero register") is usually read-only and always contains the value 0. However, for this lab, all 32 registers can be considered general registers. Further, do not need to consider the signed extension of immediate values. Each update to a register should be fairly straightforward, similar to above.
## Examples/testing
Consider the following sequence of MIPS instructions:
```asm
addi $0, $0, 21834 # r[0] = r[0] + 21834
add $1, $0, $0 # r[1] = r[0] + r[0]
sub $2, $1, $0 # r[2] = r[1] - r[0]
ori $3, $2, 1 # r[3] = r[2] | 1
```
In order to execute this series of instructions, each instruction will need to be translated to its binary equivalent by using an assembler. Using your [MIPS cheatsheet](https://sakai.unc.edu/access/content/group/167842e9-e6e0-4d16-81bd-842fcf59831e/Supplemental/mips_cheat_sheet.pdf), you can do this translation yourself.
```text
00100000000000000101010101001010
00000000000000000000100000100000
00000000001000000001000000100010
00110100010000110000000000000001
```
For this lab, each instruction is accepted as an integer through standard input, so each binary instruction will need to undergo another conversion:
```text
536892746
2080
2101282
876806145
```
You can then enter each integer into the simulator. To exit the simulator, you can enter the integer `4294967295`. The `main` method handles this special instruction, so you don't need to implement it.
```text
Please enter your instruction as a 32-bit integer: 536892746
Current register status:
[21834, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
Please enter your instruction as a 32-bit integer: 2080
Current register status:
[21834, 43668, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
Please enter your instruction as a 32-bit integer: 2101282
Current register status:
[21834, 43668, 21834, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
Please enter your instruction as a 32-bit integer: 876806145
Current register status:
[21834, 43668, 21834, 21835, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
Please enter your instruction as a 32-bit integer: 4294967295
```
## Submit your assignment
1. Use git to push your finished code to this GitHub repository.
2. Go to the COMP 211 course in Gradescope and click on the assignment called **Lab 04**.
3. Click on the option to **Submit Assignment** and choose GitHub as the submission method.
4. You should see a list of your public repositories. Select the one named **lab-04-yourname** and submit it.
5. Your assignment should be autograded within a few seconds, and you will receive feedback for the autograded portion.
6. If you receive all the points, then you have completed this lab! Otherwise, you are free to keep pushing commits to your GitHub repository and submit for regrading up until the deadline of the lab.

29
lab-04/bit_utils.c Normal file
View File

@ -0,0 +1,29 @@
// Do not edit this file
#include "bit_utils.h"
unsigned int mask(unsigned int num, unsigned int bits) {
return num & bits;
}
unsigned int set(unsigned int num, unsigned int bits) {
return num | bits;
}
unsigned int inverse(unsigned int num, unsigned int bits) {
return num ^ bits;
}
unsigned int bit_select(unsigned int num,
unsigned int startbit,
unsigned int endbit) {
startbit++;
num <<= (SIZE - startbit);
num >>= (SIZE - startbit + endbit);
return num;
}
unsigned int barrel_shift(unsigned int num, unsigned int shamt) {
unsigned int right_bits = num << (sizeof(unsigned int) * 8 - shamt);
return (num >> shamt) | right_bits;
}

30
lab-04/bit_utils.h Normal file
View File

@ -0,0 +1,30 @@
// Do not edit this file
#include <assert.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define SIZE sizeof(unsigned int) * 8
// Returns num after mask has been applied.
unsigned int mask(unsigned int num, unsigned int bits);
// Returns num after bits have been set.
unsigned int set(unsigned int num, unsigned int bits);
// Returns num after bits have been inversed.
unsigned int inverse(unsigned int num, unsigned int bits);
// Returns the bits in the number from startbit to
// end bit (including startbit and endbit);
unsigned int bit_select(unsigned int num,
unsigned int startbit,
unsigned int endbit);
// Returns value of num circularly shifted to the right by
// shamt (shift amount) positions. The bits that are shifted
// out of the right end are put back in at the left end.
// For example, barrel_shift(0x00F0FFFF, 16) is 0xFFFF00F0
unsigned int barrel_shift(unsigned int num, unsigned int shamt);

68
lab-04/instructions.c Normal file
View File

@ -0,0 +1,68 @@
// PID: 730677144
// I pledge the COMP 211 honor code.
#include <stdint.h>
#include <stdlib.h>
#include "bit_utils.h"
#include "instructions.h"
// ------------------------------------
// Determines whether instruct is an
// R-type or I-type instruction
//
// Arguments: an unsigned 32-bit integer
//
// Return: instruction_type: R_TYPE or I_TYPE (see structures)
//
instruction_type get_type_of_instruction(uint32_t instruct) {
if (bit_select(instruct, OPCODE_START_BIT, OPCODE_END_BIT) == 0) {
return R_TYPE;
} else {
return I_TYPE;
}
} // end get_type_of_instruction() function
// ------------------------------------
// Creates an R-type instruction
// based on the integer given (see structures)
//
// Arguments: an unsigned 32-bit integer
//
// Return: a pointer to an r_instruction (see structures).
// This consists of the following structure members
// you will have to set: rs, rt, rd, shamt, func
//
r_instruction* create_r_instruction(uint32_t instruct) {
r_instruction* r = malloc(sizeof(r_instruction));
r->rs = bit_select(instruct, RS_START_BIT, RS_END_BIT);
r->rt = bit_select(instruct, RT_START_BIT, RT_END_BIT);
r->rd = bit_select(instruct, RD_START_BIT, RD_END_BIT);
r->shamt = bit_select(instruct, SHAMT_START_BIT, SHAMT_END_BIT);
r->func = bit_select(instruct, FUNC_START_BIT, FUNC_END_BIT);
return r;
} // end create_r_instruction() function
// ------------------------------------
// Creates an I-type instruction
// based on the integer given (see structures)
//
// Arguments: an unsigned 32-bit integer
//
// Return: a pointer to an i_instruction (see structures).
// This consists of the following structure members
// you will have to set: opcode, rs, rt, immediate
//
i_instruction* create_i_instruction(uint32_t instruct) {
i_instruction* i = malloc(sizeof(i_instruction));
i->opcode = bit_select(instruct, OPCODE_START_BIT, OPCODE_END_BIT);
i->rs = bit_select(instruct, RS_START_BIT, RS_END_BIT);
i->rt = bit_select(instruct, RT_START_BIT, RT_END_BIT);
i->immediate = bit_select(instruct, IMMEDIATE_START_BIT, IMMEDIATE_END_BIT);
return i;
} // end create_i_instruction() function

91
lab-04/instructions.h Normal file
View File

@ -0,0 +1,91 @@
// Do not edit this file
#ifndef INSTRUCTIONS_H
#define INSTRUCTIONS_H
#include <stdint.h>
/// CONSTANTS
#define OPCODE_START_BIT 31
#define OPCODE_END_BIT 26
#define RS_START_BIT 25
#define RS_END_BIT 21
#define RT_START_BIT 20
#define RT_END_BIT 16
#define RD_START_BIT 15
#define RD_END_BIT 11
#define SHAMT_START_BIT 10
#define SHAMT_END_BIT 6
#define FUNC_START_BIT 5
#define FUNC_END_BIT 0
#define IMMEDIATE_START_BIT 15
#define IMMEDIATE_END_BIT 0
#define R_TYPE_OPCODE 0b000000
#define ADDI_OPCODE 0b001000
#define ANDI_OPCODE 0b001100
#define ORI_OPCODE 0b001101
#define SLL_FUNC 0b000000
#define SRA_FUNC 0b000011
#define ADD_FUNC 0b100000
#define SUB_FUNC 0b100010
#define AND_FUNC 0b100100
#define OR_FUNC 0b100101
#define NOR_FUNC 0b100111
/// STRUCTURES
typedef struct {
uint8_t rs;
uint8_t rt;
uint8_t rd;
uint8_t shamt;
uint8_t func;
} r_instruction;
typedef struct {
uint8_t opcode;
uint8_t rs;
uint8_t rt;
uint16_t immediate;
} i_instruction;
typedef enum { R_TYPE, I_TYPE } instruction_type;
/// FUNCTIONS
// ------------------------------------
// Determines whether instruct is an
// R-type or I-type instruction
//
// Arguments: an unsigned 32-bit integer
//
// Return: instruction_type: R_TYPE or I_TYPE (see structures)
//
instruction_type get_type_of_instruction(uint32_t instruct);
// ------------------------------------
// Creates an R-type instruction
// based on the integer given (see structures)
//
// Arguments: an unsigned 32-bit integer
//
// Return: a pointer to an r_instruction (see structures).
// This consists of the following structure members
// you will have to set: rs, rt, rd, shamt, func
//
r_instruction* create_r_instruction(uint32_t instruct);
// ------------------------------------
// Creates an I-type instruction
// based on the integer given (see structures)
//
// Arguments: an unsigned 32-bit integer
//
// Return: a pointer to an i_instruction (see structures).
// This consists of the following structure members
// you will have to set: opcode, rs, rt, immediate
//
i_instruction* create_i_instruction(uint32_t instruct);
#endif // INSTRUCTIONS_H

BIN
lab-04/lab04 Executable file
View File

Binary file not shown.

140
lab-04/lab04.c Normal file
View File

@ -0,0 +1,140 @@
// PID: 730677144
// I pledge the COMP 211 honor code.
#include <limits.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include "instructions.h"
#define REGISTER_SIZE 32
void execute_r_instruction(r_instruction* instruct);
void execute_i_instruction(i_instruction* instruct);
static uint16_t registers[REGISTER_SIZE] = {0};
int main() {
uint32_t instruct;
while (true) {
printf("Please enter your instruction as a 32-bit integer: ");
if (scanf("%u", &instruct) != 1) {
printf("\n");
fprintf(stderr, "Failed to read instruction!\n");
return EXIT_FAILURE;
}
if (instruct == UINT_MAX)
return EXIT_SUCCESS;
if (get_type_of_instruction(instruct) == R_TYPE) {
r_instruction* r_instruct = create_r_instruction(instruct);
execute_r_instruction(r_instruct);
free(r_instruct);
} else { // I_TYPE
i_instruction* i_instruct = create_i_instruction(instruct);
execute_i_instruction(i_instruct);
free(i_instruct);
}
printf("Current register status:\n");
printf("[");
for (int i = 0; i < REGISTER_SIZE; i++) {
printf("%d", registers[i]);
if (i != REGISTER_SIZE - 1)
printf(", ");
}
printf("]\n");
}
}
// ------------------------------------
// Takes the r_instruction
// you created in Part 1 and, based on the MIPS instruction,
// performs the operation and updates the 'registers' array
// (see top of file).
//
// Hint: the "func" bits determine the operation (i.e., SLL,
// SRA, ADD, SUB, AND, OR).
//
// Arguments: r_instruction structure
//
// Return: None
//
void execute_r_instruction(r_instruction* instruct) {
switch (instruct->func) {
case SLL_FUNC:
registers[instruct->rd] = registers[instruct->rt]
<< instruct->shamt;
break;
case SRA_FUNC:
registers[instruct->rd] =
registers[instruct->rt] >> instruct->shamt;
break;
case ADD_FUNC:
registers[instruct->rd] =
registers[instruct->rs] + registers[instruct->rt];
break;
case SUB_FUNC:
registers[instruct->rd] =
registers[instruct->rs] - registers[instruct->rt];
break;
case AND_FUNC:
registers[instruct->rd] =
registers[instruct->rs] & registers[instruct->rt];
break;
case OR_FUNC:
registers[instruct->rd] =
registers[instruct->rs] | registers[instruct->rt];
break;
case NOR_FUNC:
registers[instruct->rd] =
~(registers[instruct->rs] | registers[instruct->rt]);
break;
default:
fprintf(stderr, "Invalid function code!\n");
exit(EXIT_FAILURE);
}
} // end execute_r_instruction() function
// ------------------------------------
// Takes the i_instruction
// you created in Part 1 and, based on the MIPS instruction,
// performs the operation and updates the 'registers' array
// (see top of file).
//
// Hint: the "opcode" bits determine the operation (.e., ADDI,
// ANDI, ORI).
//
// Arguments: i_instruction structure
//
// Return: None
//
void execute_i_instruction(i_instruction* instruct) {
switch (instruct->opcode) {
case ADDI_OPCODE:
registers[instruct->rt] =
registers[instruct->rs] + instruct->immediate;
break;
case ANDI_OPCODE:
registers[instruct->rt] =
registers[instruct->rs] & instruct->immediate;
break;
case ORI_OPCODE:
registers[instruct->rt] =
registers[instruct->rs] | instruct->immediate;
break;
default:
fprintf(stderr, "Invalid opcode!\n");
exit(EXIT_FAILURE);
}
} // end execute_i_instruction() function

10
lab-05/.gitignore vendored Normal file
View File

@ -0,0 +1,10 @@
# Build files
*.o
*.out
main
# macOS
.DS_Store
# IDE
.idea

25
lab-05/Makefile Normal file
View File

@ -0,0 +1,25 @@
CC=gcc
CFLAGS=-c -Wall -g #-std=c11
all: main
main: memory.o cache.o bit_utils.o main.o
$(CC) memory.o cache.o bit_utils.o main.o -o main -lm
memory.o: memory.c
$(CC) $(CFLAGS) memory.c
cache.o: cache.c
$(CC) $(CFLAGS) cache.c
bit_utils.o: bit_utils.c
$(CC) $(CFLAGS) bit_utils.c
main.o: main.c
$(CC) $(CFLAGS) main.c
clean:
/bin/rm -f main *.o *.gz
run: main memory.txt
./main memory.txt

234
lab-05/README.md Normal file
View File

@ -0,0 +1,234 @@
<!-- omit in toc -->
# Lab 5
Caches are implemented in computing systems because they mitigate the lengthy time that it takes to retrieve data from memory. This serves as the primary motivation for this lab, in which you will implement a cache simulator that supports the direct mapping (DM) and fully associative (FA) cache mapping techniques.
This lab reinforces the following concepts:
* Old
* Structs
* Interfaces (headers)
* Pointers (passing values by reference)
* Bit manipulation (`bit_utils.c` from a previous lab is included here)
* New
* Caches and cache algorithms
* Addressing physical memory
To simplify the lab, the size of the cache and physical memory in this simulator will be much smaller than they would be in practice. In particular, you will be working with 8 cache lines and physical memory with 256 addresses, each of which stores a byte.
<details open>
<summary>Contents</summary>
- [Pre-lab knowledge](#pre-lab-knowledge)
- [Background reading](#background-reading)
- [Lab structure](#lab-structure)
- [Running code](#running-code)
- [Part 0. number\_of\_blocks](#part-0-number_of_blocks)
- [Testing](#testing)
- [Part 1. Direct mapping](#part-1-direct-mapping)
- [Testing](#testing-1)
- [Part 2. Fully associative mapping](#part-2-fully-associative-mapping)
- [Testing](#testing-2)
- [Submit your assignment](#submit-your-assignment)
</details>
## Pre-lab knowledge
### Background reading
Refer to the following for a review of caches and the differences between the direct mapping and fully associative cache mapping techniques. As mentioned earlier, you will implement both techniques.
* (Required) [System concepts, Main Memory and Memory Hierarchy](https://uncch.instructure.com/users/9947/files/5587554?verifier=5pVYCbHJeS551teiKVw1IJezkRZ2uGCeTdpQ1bdu&wrap=1).
* (Required) [Cache Memory, Mapping Algorithms, and the Principle of Locality](https://uncch.instructure.com/users/9947/files/5661387?verifier=FLrrKMVo00veF13U7m7Newwf4c52dBHJB4FWz7iq&wrap=1)
* (Optional) [CSApp Section 6.2](https://uncch.instructure.com/users/9947/files/4526297?verifier=GsaGSp6QkNQvZGMOCCiuAT4eyRWq70bxIKOgxjZr&wrap=1)
* (Optional) If you need to review the relationship between pointers and arrays, see [Chapter 5 of The C Programming Language](https://uncch.instructure.com/users/9947/files/4526297?verifier=GsaGSp6QkNQvZGMOCCiuAT4eyRWq70bxIKOgxjZr&wrap=1).
### Lab structure
```text
.
├── Makefile
├── README.md
├── bit_utils.c - Do not modify (functions from Lab 3)
├── bit_utils.h - Do not modify
├── cache.c - Implement the cread function (DM and FA)
├── cache.h - Do not modify
├── main.c - Do not modify. Contains main function
├── memory.c - Implement number_of_blocks
├── memory.h - Do not modify
├── memory.txt - Do not modify. Contains sample memory values to be read by memory.c. Each line represents a distinct memory address, and each byte is the value stored at that address.
└── tests - Contains files for testing
├── directmapping_input0.txt
├── directmapping_input1.txt
├── directmapping_output0.txt
├── directmapping_output1.txt
├── fullyassociative_input0.txt
├── fullyassociative_input1.txt
├── fullyassociative_output0.txt
└── fullyassociative_output1.txt
```
Please familiarize yourself with these files. You can open all the `.c` and `.h` files in the current working directory in vim tabs with the command `vim -p *.c *.h`, and you can navigate the tabs with `gt` and `gT`.
In particular, pay attention to the following:
* The defined constants and function prototypes in the `.h` files and how they correspond with the cache mapping algorithms and the size of blocks, address length, cache size, etc.
* The control flow of the main function in `main.c`
* The `cache_line` struct, defined as follows. You should also view the `initialize_cache` function in `cache.c` to see how this struct is used.
```c
typedef struct {
int tag;
int hit_count;
unsigned int* block;
} cache_line;
```
While there are a lot of moving parts in this lab, there are only two functions you need to implement!
### Running code
Similarly to previous labs, you are provided a `Makefile` for running the code.
## Part 0. number_of_blocks
In `memory.c`, implement `number_of_blocks`. There is a docstring for this function in `memory.h`.
The specification for this function is simple. Given the number of bits it takes to represent the number of addresses used in the simulation and the number of offset bits used in the cache, how many blocks can the address space be divided into?
`number_of_blocks` should return the `FAIL` constant (defined in `memory.h`) if either of the arguments is not positive or if `addr_bits` is less than `num_block_offset_bits`.
For example, if the number of addresses is 256 and the number of offset bits is 2 (resulting in a block size of 2<sup>2</sup> = 4), then our address space can be divided into 64 blocks of 4 addresses each.
In our simulation, the number of addresses is always 256, but this function should work for any address space size and number of offset bits.
**Note**: You have access to functions such as `exp2` because this file includes `math.h`.
### Testing
To test your `number_of_blocks` function, you may write some sample function calls with print statements at the beginning of the `main` function in `main.c`. Once you are convinced you are calculating the correct number of blocks, delete your debug code and submit to Gradescope to confirm. Note that you'll get some warnings from gcc because not all the functions have been implemented. You can ignore these for now.
## Part 1. Direct mapping
In `cache.c`, implement the direct mapping mode of the `cread` function, which reads a value from the cache. There is a docstring for this function in `cache.h`.
This function performs either direct mapping or fully associative mapping based on the value of the `cmf` parameter. Note that in `cache.h`, we have defined the constants `DM` and `FA`. If `cmf` is equal to `DM`, then `cread` should apply the direct mapping algorithm; else, if it is equal to `FA`, then it should apply the fully associative algorithm.
For this part, you need only implement the direct mapping algorithm. A paraphrased version of the algorithm is supplied here (for complete details, see [Background reading](#background-reading)), but some details (such as dealing with the `hit` and `replace` parameters and modifying some properties of `cache_line` structs) are omitted and are left for you to figure out.
* Use `bit_select` from `bit_utils.c` to extract the block offset, line, and tag bits (derived from `NUM_BLOCK_OFFSET_BITS`, `NUM_LINE_BITS` and `NUM_TAG_BITS_DM`) from `hex_addr`.
* Check if the cache line corresponding to the line bits has tag bits that match with the tag you are searching for. You may want to review the definition of the `cache_line` struct.
* If the tag bits match, then you have found the address you are searching for in the cache. You do not need to replace anything, and that cache line's `hit_count` should be incremented.
* Else, if the tag bits do not match, there is a cache miss (i.e., the address we are searching for is not in the cache). In this case, either the cache line is empty (i.e., the tag is equal to the `EMPTY` constant in `cache.h`) or not empty.
* Whether empty or not empty, we are now going to set this cache line's memory `block` and `tag` to those of the block we are searching for. We will also set `hit_count` to 1.
* To set `block` correctly, you will want to use `NUM_BLOCK_OFFSET_BITS` from `memory.h`. You will also need to use `block_location` and `phy_memory`, both `unsigned int*`.
* Set `hit` and `replace` to appropriate boolean values (`true | false`) based on whether there was a cache hit and whether an existing value in the cache line was replaced.
* If the tag bits did not match and the cache line was empty, this is not considered a replacement (rather, it is an initialization).
* Set `ret_val` to be the value in memory corresponding to the requested `hex_addr`.
### Testing
To test your code, you will run the executable generated by the `main.c` file, which takes in `memory.txt` as a command line argument to initialize the simulator's physical memory. The command to run your program in this manner after compiling is `./main memory.txt`. Or you can simply run `make run`, which maps to that command.
Your testing of the algorithm will consist of entering hexadecimal addresses into the simulator and seeing if the output of the cache acts as you would expect. In particular, look out for the following:
* Does the tag referenced in the cache correspond to the appropriate hexadecimal address from `memory.txt`?
* Is the return value the same as what is present in the corresponding hexadecimal address in `memory.txt`?
* If a block of addresses is already stored in the cache, does entering an address from that block result in a cache hit (and vice versa)?
* Does a particular hexadecimal address always map to the same cache line?
Like previous labs, you are given sample input and output files. However, you will not be able to simply output your result and compare with `diff`. This is partly because the main loop of `main.c` loops infinitely without keyboard intervention and because we want you to carefully sample the examples to understand the cache behavior. Thus, the input files include a sequence of values that you should enter manually and the output files contain everything that should be output to the console.
For example, examine `directmapping_input0.txt`:
```text
1
00
01
02
03
09
0A
0B
10
20
20
40
```
The 1 indicates that we have chosen 1 (direct mapping) as our cache mapping function. Every subsequent number is a hexadecimal address in physical memory that the cache attempts to read. The expected results are in `directmapping_output1.txt`. The following snippet from this file demonstrates expected I/O:
```text
------------------------
[STEP 1] Setting up physical memory
------------------------
Physical memory addressable bits = 8, total number of blocks = 64
------------------------
[STEP 2] Determining physical memory block locations
------------------------
------------------------
[STEP 3] Select cache mapping function (CMF)
------------------------
1 = Direct mapping
2 = Fully associative
------------------------
Please enter 1 or 2: 1 // Input on this line.
------------------------
[STEP 4] initializing cache
------------------------
------------------------
[STEP 5] Starting simulation
------------------------
CMF is Direct Mapping
To exit simulation, press Ctrl+C
Please enter 8-bit hexadecimal address: 00 // Input on this line.
Entered Hexadecimal (Base-16) address 00 (Base-10 value 0)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 1
1 -1 0
2 -1 0
3 -1 0
4 -1 0
5 -1 0
6 -1 0
7 -1 0
[MISS:No Replacement] The byte value at memory address 00 is 7F
```
The way to interpret this sequence is that the user entered `1` to choose the direct mapping cache algorithm. Then, the user entered the hexadecimal address `00` as the address whose value should be read from the cache. Since the cache was empty, this was a cache miss and the block of physical memory corresponding to address `00` was loaded into cache line 0. If you examine `memory.txt`, you will see that the value stored in the first line is indeed `7F`.
## Part 2. Fully associative mapping
You will now implement the second component of the `cread` function, which uses the fully associative mapping algorithm when the user supplies a `cmf` parameter of `FA`. As was the case in the previous part, you can find more details about the algorithm in [Background reading](#background-reading), but here is a paraphrased version of the algorithm:
* Use `bit_select` from `bit_utils.c` to extract the block offset and tag bits (derived from `NUM_BLOCK_OFFSET_BITS` and `NUM_TAG_BITS_FA`) from `hex_addr`. Note that because this is fully associative, we do not have line bits.
* Loop through each of the cache lines and determine which, if any, needs to be replaced.
* If the tag of any cache line matches the tag you are searching for, then this is a cache hit (i.e., the address you are searching for has already been cached), and you do not need to replace anything. Increment that cache line's `hit_count`.
* Otherwise, if there are cache lines that have not been used yet (i.e., empty `tag`), cache the value in the first available open line (i.e. the one of lowest index in the array of cache lines). To do so, set the cache line's `block` and `tag` appropriately (similar to the way you did it for [DM](#part-1-direct-mapping)). Also, set `hit_count` to 1.
* If every cache line has been used (i.e., cache full), use the Least Frequently Used replacement strategy to determine which cache line to replace. That is, replace the cache line with the fewest number of hits. In the event of a tie, use the cache line with a lower index in the array of cache lines.
* Note that this means that in the above cases, you must update the relevant cache lines' `hit_count` accordingly and keep track of a minimum `hit_count`.
* Set `hit` and `replace` to appropriate boolean values, similar to the way you did it for [DM](#part-1-direct-mapping).
* As before, if an empty cache line is initialized, this is not considered a replacement.
* Set `ret_val` to be the value in memory corresponding to the requested `hex_addr`.
### Testing
Testing for this part works the same way as in the previous part. You just need to use the appropriate sample files. However, since the fully associative algorithm differs from direct mapping, it will not be the case that a particular hexadecimal address always maps to the same cache line.
## Submit your assignment
1. Use git to push your finished code to this GitHub repository.
2. Go to the COMP 211 course in Gradescope and click on the assignment called **Lab 5**.
3. Click on the option to **Submit Assignment** and choose GitHub as the submission method.
4. You should see a list of your public repositories. Select the one named **lab-05-yourname** and submit it.
5. Your assignment should be autograded within a few seconds and you will receive feedback for the autograded portion.
6. If you receive all the points, then you have completed this lab! Otherwise, you are free to keep pushing commits to your GitHub repository and submit for regrading up until the deadline of the lab.

29
lab-05/bit_utils.c Normal file
View File

@ -0,0 +1,29 @@
// Do not edit this file
#include "bit_utils.h"
unsigned int mask(unsigned int num, unsigned int bits) {
return num & bits;
}
unsigned int set(unsigned int num, unsigned int bits) {
return num | bits;
}
unsigned int inverse(unsigned int num, unsigned int bits) {
return num ^ bits;
}
unsigned int bit_select(unsigned int num,
unsigned int startbit,
unsigned int endbit) {
startbit++;
num <<= (SIZE - startbit);
num >>= (SIZE - startbit + endbit);
return num;
}
unsigned int barrel_shift(unsigned int num, unsigned int shamt) {
unsigned int right_bits = num << (sizeof(unsigned int) * 8 - shamt);
return (num >> shamt) | right_bits;
}

30
lab-05/bit_utils.h Normal file
View File

@ -0,0 +1,30 @@
// Do not edit this file
#include <assert.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define SIZE sizeof(unsigned int) * 8
// Returns num after mask has been applied.
unsigned int mask(unsigned int num, unsigned int bits);
// Returns num after bits have been set.
unsigned int set(unsigned int num, unsigned int bits);
// Returns num after bits have been inversed.
unsigned int inverse(unsigned int num, unsigned int bits);
// Returns the bits in the number from startbit to
// end bit (including startbit and endbit);
unsigned int bit_select(unsigned int num,
unsigned int startbit,
unsigned int endbit);
// Returns value of num circularly shifted to the right by
// shamt (shift amount) positions. The bits that are shifted
// out of the right end are put back in at the left end.
// For example, barrel_shift(0x00F0FFFF, 16) is 0xFFFF00F0
unsigned int barrel_shift(unsigned int num, unsigned int shamt);

170
lab-05/cache.c Normal file
View File

@ -0,0 +1,170 @@
// PID: 730677144
// I pledge the COMP 211 honor code.
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include "bit_utils.h"
#include "cache.h"
#include "memory.h"
/**
* Global variables. The extern ones are initialized in memory.c and are
* accessible via the extern keyword
*/
extern unsigned int* phy_memory;
extern unsigned int* block_location;
extern unsigned int addr_bits;
cache_line** cache;
int initialize_cache(unsigned int number_of_lines) {
unsigned int line;
// Allocate memory for the cache (array of cache lines).
cache = malloc(sizeof(cache_line*) * number_of_lines);
// For each cache line, allocate memory and initialize the cache line.
if (cache != NULL) {
for (line = 0; line < number_of_lines; line++) {
cache[line] = (cache_line*)malloc(sizeof(cache_line));
cache[line]->tag = EMPTY;
cache[line]->hit_count = 0;
cache[line]->block =
malloc(sizeof(unsigned int) * (int)exp2(NUM_BLOCK_OFFSET_BITS));
}
} else {
return FAIL;
}
return OK;
}
int cread(unsigned int cmf, unsigned int* hex_addr, bool* hit, bool* replace) {
// Either the value at the requested hexadecimal address or FAIL
int ret_val = FAIL;
// Initialize these variables by
// extracting the line (for DM, not FA), tag, and block offset bits from
// hex_addr
unsigned int line, tag, block_offset;
// (Optional) Indicates a line that is open and thus usable
int open_line;
// (Optional) For DM, indicates the cache line that should be replaced
int replace_line;
// For FA, keeps track of LFU cache line
int min_hit_cnt = (int)1E10;
// For FA, keeps track of index of LFU cache line
int min_line;
// Variables that are passed by reference
// Must indicate to the driver code whether there was a cache hit and
// whether we had to overwrite and replace something
*hit = false;
*replace = false;
if ((cmf == DM) && ((*hex_addr) < exp2(addr_bits))) {
tag = bit_select(*hex_addr, addr_bits - 1, addr_bits - NUM_TAG_BITS_DM);
line = bit_select(*hex_addr, addr_bits - NUM_TAG_BITS_DM - 1,
NUM_BLOCK_OFFSET_BITS);
block_offset = bit_select(*hex_addr, NUM_BLOCK_OFFSET_BITS - 1, 0);
if (cache[line]->tag == tag) {
// hit
*hit = true;
cache[line]->hit_count++;
ret_val = cache[line]->block[block_offset];
} else {
// miss
if (cache[line]->tag == EMPTY) {
open_line = line;
} else {
replace_line = line;
*replace = true;
}
cache[line]->tag = tag;
cache[line]->hit_count = 1;
unsigned int mem_index =
block_location[*hex_addr >> NUM_BLOCK_OFFSET_BITS];
memcpy(cache[line]->block, phy_memory + mem_index,
sizeof(unsigned int) * (int)exp2(NUM_BLOCK_OFFSET_BITS));
ret_val = cache[line]->block[block_offset];
}
} else if ((cmf == FA) && ((*hex_addr) < exp2(addr_bits))) {
tag = bit_select(*hex_addr, addr_bits - 1, addr_bits - NUM_TAG_BITS_FA);
block_offset = bit_select(*hex_addr, NUM_BLOCK_OFFSET_BITS - 1, 0);
for (line = 0; line < NUM_LINES; line++) {
if (cache[line]->tag == tag) {
// hit
*hit = true;
cache[line]->hit_count++;
ret_val = cache[line]->block[block_offset];
break;
}
}
if (!(*hit)) {
for (line = 0; line < NUM_LINES; line++) {
if (cache[line]->tag == EMPTY) {
replace_line = line;
break;
}
}
if (line == NUM_LINES) {
for (line = 0; line < NUM_LINES; line++) {
if (cache[line]->hit_count < min_hit_cnt) {
min_hit_cnt = cache[line]->hit_count;
min_line = line;
}
}
replace_line = min_line;
*replace = true;
}
cache[replace_line]->tag = tag;
cache[replace_line]->hit_count = 1;
unsigned int mem_index =
block_location[*hex_addr >> NUM_BLOCK_OFFSET_BITS];
memcpy(cache[replace_line]->block, phy_memory + mem_index,
sizeof(unsigned int) * (int)exp2(NUM_BLOCK_OFFSET_BITS));
ret_val = cache[replace_line]->block[block_offset];
}
}
// Print state of cache after mapping algorithm is applied
cprint();
return ret_val;
}
void cprint() {
unsigned int line;
printf("\n---------------------------------------------\n");
printf("line\ttag\tnum of hits\n");
printf("---------------------------------------------\n");
for (line = 0; line < NUM_LINES; line++) {
if (cache[line]->tag == EMPTY) {
printf("%d\t%d\t%d\n", line, cache[line]->tag,
cache[line]->hit_count);
} else {
printf("%d\t%02X\t%d\n", line, cache[line]->tag,
cache[line]->hit_count);
}
}
}

79
lab-05/cache.h Normal file
View File

@ -0,0 +1,79 @@
// Do not edit this file
#ifndef CACHE_H
#define CACHE_H
#include <stdbool.h>
// Return values
#define OK 0
#define FAIL -1
// Cache mapping functions
#define DM 1 // Direct Mapping
#define FA 2 // Fully Associative
// Simulation parameters
#define NUM_LINE_BITS 3
#define NUM_TAG_BITS_DM 3
#define NUM_TAG_BITS_FA 6
// exp2(NUM_LINE_BITS)
#define NUM_LINES (1 << NUM_LINE_BITS)
// If cache_line->tag is EMPTY, then the cache line is considered empty
#define EMPTY -1
/**
* See cache.c initialize_cache() function to see how this struct is used
*/
typedef struct {
int tag;
int hit_count;
unsigned int* block;
} cache_line;
/**
* Initializes the cache array.
*
* Each element in the cache array is a cache_line struct.
*
* Parameters:
* number_of_lines: number of lines in the cache
* Return:
* OK (success) | FAIL (error)
*/
int initialize_cache(unsigned int number_of_lines);
/**
* Reads the cache and returns the byte at the specified physical memory address
* location.
*
* Note that hit and replace are passed by reference (pointers). You must set
* these values correctly to indicate to the driver function whether there was a
* cache hit and whether there was a replacement. These two variables behave as
* "return values" even though they are parameters.
*
* Parameters:
* cmf: cache mapping function, either DM or FA
* hex_addr: memory address pointer
* hit: set to true on cache hit, false on cache miss
* replace: set to true if a cache replacement was performed, false otherwise
* Return:
* byte value at specified memory location (success) | FAIL (error)
*/
int cread(unsigned int cmf, unsigned int* hex_addr, bool* hit, bool* replace);
/**
* Displays the cache, for debugging purposes
*
* Parameters:
* none
* Return:
* void
*/
void cprint();
#endif // CACHE_H

166
lab-05/main.c Normal file
View File

@ -0,0 +1,166 @@
// Do not edit this file
/**
* Usage (after running make): make run or ./main memory.txt (must supply 1 CLI
* argument).
*
* Main file for a cache simulator that implements the two cache mapping
* functions (CMF): 1) direct mapping (DM) 2) fully associative (FA)
*
* This is an interactive simulator that allows the user to
* 1) Select the cache mapping function (CMF)
* 2) Enter hex memory addresses
* 3) For the CMF selected, determine if the address results in a cache hit or
* miss and display to the user 4) If a cache miss, determine the cache line to
* be replaced for the chosen CMF. For FA, the replacement algorithm is least
* frequently used (LFU) based on the minimum number of cache hits.
*/
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "cache.h"
#include "memory.h"
char* CMFS[] = {"Direct Mapping", "Fully Associative"};
char* OP[] = {"MISS", "HIT"};
char* ROP[] = {"No Replacement", "Replacement"};
extern unsigned int addr_bits;
int main(int argc, char* argv[]) {
if (argc != 2) {
fprintf(stderr, "Usage: ./main memory.txt\n");
exit(1);
}
unsigned int num_blocks;
unsigned int cmf;
unsigned int hex_addr;
int byte;
bool found, replace;
addr_bits = read_memory_file(argv[1]);
if (addr_bits != FAIL) {
/*
---------------------------------------------------
STEP 1:
---------------------------------------------------
Calculate the number of blocks then display to the
user the number of physical memory addressable bits
and the total number of physical memory blocks.
*/
printf("\n------------------------\n");
printf("[STEP 1] Setting up physical memory\n");
printf("------------------------\n");
num_blocks = number_of_blocks(addr_bits, NUM_BLOCK_OFFSET_BITS);
printf(
"Physical memory addressable bits = %d, total number of blocks = "
"%d\n",
addr_bits, num_blocks);
/*
---------------------------------------------------
STEP 2:
---------------------------------------------------
Initialize the block points, i.e. determine the physical
memory starting address for each block.
*/
printf("\n------------------------\n");
printf("[STEP 2] Determining physical memory block locations\n");
printf("------------------------\n");
initialize_block_pointers(num_blocks, NUM_BLOCK_OFFSET_BITS);
/*
---------------------------------------------------
STEP 3:
---------------------------------------------------
Ask the user to choose the cache mapping function (CMF)
*/
printf("\n------------------------\n");
printf("[STEP 3] Select cache mapping function (CMF)\n");
printf("------------------------\n");
printf("1 = Direct mapping\n");
printf("2 = Fully associative\n");
printf("------------------------\n");
printf("Please enter 1 or 2: ");
scanf("%d", &cmf);
if (cmf != DM && cmf != FA) {
printf("Unknown CMF mode (%d) ... exiting\n", cmf);
exit(1);
} else {
/*
---------------------------------------------------
STEP 4:
---------------------------------------------------
Initialize cache, that is, all the cache lines should
be empty (i.e. no block of physical memory is loaded
into any cache line).
*/
printf("\n------------------------\n");
printf("[STEP 4] initializing cache\n");
printf("------------------------\n");
initialize_cache(NUM_LINES);
/*
---------------------------------------------------
STEP 5:
---------------------------------------------------
Ask the user to enter physical a memory address location
in hexadecimal format (e.g. EA), then get and display
physical memory value from cache and display to user.
*/
printf("\n------------------------\n");
printf("[STEP 5] Starting simulation\n");
printf("------------------------\n");
printf("CMF is %s\n", CMFS[cmf - 1]);
printf("To exit simulation, press Ctrl+C\n");
while (true) {
printf("\nPlease enter %d-bit hexadecimal address: ",
addr_bits);
scanf("%x", &hex_addr);
printf(
"Entered Hexadecimal (Base-16) address %02X (Base-10 value "
"%d)\n",
hex_addr, hex_addr);
byte = cread(cmf, &hex_addr, &found, &replace);
if (byte != FAIL) {
printf(
"[%s:%s] The byte value at memory address %02X is "
"%02X\n",
OP[found], ROP[replace], hex_addr, byte);
} else {
printf("Failed to read cache for memory location %02X\n",
hex_addr);
}
}
}
} else {
printf("Unable to read the memory file ( %s ) ... exiting\n", argv[1]);
}
return OK;
}

79
lab-05/memory.c Normal file
View File

@ -0,0 +1,79 @@
// PID: 730677144
// I pledge the COMP 211 honor code.
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include "bit_utils.h"
#include "memory.h"
// Global variables
unsigned int* phy_memory;
unsigned int* block_location;
unsigned int addr_bits;
int number_of_blocks(unsigned int addr_bits,
unsigned int num_block_offset_bits) {
if (addr_bits < num_block_offset_bits || num_block_offset_bits <= 0 ||
addr_bits <= 0)
return FAIL;
return exp2(addr_bits - num_block_offset_bits);
}
int read_memory_file(char* file_name) {
int addr_cnt = 0;
FILE* fhnd;
fhnd = fopen(file_name, "r");
if (fhnd != NULL) {
phy_memory = malloc(sizeof(unsigned int) * MAX_SIZE);
int fscanf_rv;
// For each line, increment total address count and store value in
// phy_memory.
while ((fscanf_rv = fscanf(fhnd, "%x\n", &phy_memory[addr_cnt])) != EOF)
addr_cnt++;
phy_memory[addr_cnt] = '\0';
fclose(fhnd);
} else {
// If fopen didn't work, no addresses of physical memory were counted.
addr_cnt = FAIL;
fprintf(stderr, "Error: Could not open file %s\n", file_name);
}
if (MEM_DEBUG)
printf("Number of bytes read: %d\n", addr_cnt);
if (addr_cnt != FAIL)
return ceil(log2(addr_cnt));
else
return FAIL;
}
void initialize_block_pointers(unsigned int num_blocks,
unsigned int num_block_offset_bits) {
int i;
/**
* Here, we create a mapping to the starting addresses of each block.
* Blocks are groupings of physical memory into chunks.
* For example, if num_block_offset_bits is 3, then each block is size 2^3.
* The block locations would be [0, 8, 16, 24, ...]
*/
block_location = malloc(sizeof(unsigned int) * num_blocks);
for (i = 0; i < num_blocks; i++) {
block_location[i] = i * exp2(num_block_offset_bits);
if (MEM_DEBUG)
printf("starting block address (base-16) %02X (%d base-10)\n",
block_location[i], block_location[i]);
}
}

57
lab-05/memory.h Normal file
View File

@ -0,0 +1,57 @@
// Do not edit this file
#ifndef MEMORY_H
#define MEMORY_H
// Return values
#define OK 0
#define FAIL -1
// Simulation parameters
#define MEM_DEBUG 0
#define NUM_BLOCK_OFFSET_BITS 2
#define MAX_SIZE 1000
/**
* Computes the number of blocks given the number of addressable bits and block
* offset bits.
*
* For example (from README),
* if the number of addresses is 256 and the number of block offset bits is 2,
* then the block size is 2^2=4. Thus, the address space can be divided into 64
* blocks of 4 addresses each.
*
* Parameters:
* addr_bits: number of addressable bits
* num_block_offset_bits: number of block offset bits
* Return:
* number of blocks (success) | FAIL (error)
*/
int number_of_blocks(unsigned int addr_bits,
unsigned int num_block_offset_bits);
/**
* Reads the bytes in memory.txt to initialize the phy_memory array
*
* Parameters:
* file_name: name of the file to read
* Return:
* number of addressable bits (no error) | FAIL (error)
*/
int read_memory_file(char* file_name);
/**
* Identifies the starting physical memory address location for each block.
*
* Parameters:
* num_blocks: number of blocks
* num_block_offset_bits: number of block offset bits
* Return:
* void
*/
void initialize_block_pointers(unsigned int num_blocks,
unsigned int num_block_offset_bits);
#endif // MEMORY_H

256
lab-05/memory.txt Normal file
View File

@ -0,0 +1,256 @@
7F
24
7A
41
5E
7F
2B
47
33
32
53
7F
78
67
2E
7F
68
7F
7F
60
7F
7F
77
7F
7F
6D
55
7F
7F
7F
60
7F
7F
7F
7F
4F
12
2E
18
76
02
7F
7F
00
08
35
74
20
02
7F
5A
7F
6F
6F
0D
0D
17
7F
3D
7F
7F
7F
7D
38
3A
7F
7F
59
76
7F
7F
29
7F
7F
6E
7F
64
2E
7F
7F
54
7F
7F
7F
20
3B
06
7F
1C
68
7F
7F
5E
35
70
7F
20
78
7F
0B
7F
7F
48
22
7F
7F
7F
7F
31
7F
58
6B
28
7F
7F
7F
7F
11
7F
7F
7F
7F
7F
28
75
7F
7F
7F
7F
7F
7F
7F
09
7F
68
09
7F
27
25
7F
41
53
66
68
62
7F
2B
30
18
52
7F
3C
7F
7F
7F
7F
4B
4F
7F
53
7F
7F
7F
43
7F
3C
74
62
7F
7F
7F
7F
3C
7F
0D
7F
7F
7F
7F
7F
68
00
7F
35
38
53
18
7F
7F
7F
56
7F
7F
7F
7F
5B
7F
58
7F
7F
7F
20
7F
06
6A
7F
7F
5E
7F
7F
3E
21
39
59
49
7F
0D
7F
2A
7F
2B
7F
7F
5B
0C
36
65
55
3B
7F
7F
7F
70
7F
01
7F
7F
3B
7F
7F
7F
7F
7F
54
39
50
7F
7F
4A
67
7F
7F
7F
34
7F
7F

12
lab-05/tests/directmapping_input0.txt Normal file
View File

@ -0,0 +1,12 @@
1
00
01
02
03
09
0A
0B
10
20
20
40

15
lab-05/tests/directmapping_input1.txt Normal file
View File

@ -0,0 +1,15 @@
1
00
01
01
02
03
05
08
0d
15
22
37
59
90
e9

191
lab-05/tests/directmapping_output0.txt Normal file
View File

@ -0,0 +1,191 @@
------------------------
[STEP 1] Setting up physical memory
------------------------
Physical memory addressable bits = 8, total number of blocks = 64
------------------------
[STEP 2] Determining physical memory block locations
------------------------
------------------------
[STEP 3] Select cache mapping function (CMF)
------------------------
1 = Direct mapping
2 = Fully associative
------------------------
Please enter 1 or 2:
------------------------
[STEP 4] initializing cache
------------------------
------------------------
[STEP 5] Starting simulation
------------------------
CMF is Direct Mapping
To exit simulation, press Ctrl+C
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 00 (Base-10 value 0)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 1
1 -1 0
2 -1 0
3 -1 0
4 -1 0
5 -1 0
6 -1 0
7 -1 0
[MISS:No Replacement] The byte value at memory address 00 is 7F
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 01 (Base-10 value 1)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 2
1 -1 0
2 -1 0
3 -1 0
4 -1 0
5 -1 0
6 -1 0
7 -1 0
[HIT:No Replacement] The byte value at memory address 01 is 24
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 02 (Base-10 value 2)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 3
1 -1 0
2 -1 0
3 -1 0
4 -1 0
5 -1 0
6 -1 0
7 -1 0
[HIT:No Replacement] The byte value at memory address 02 is 7A
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 03 (Base-10 value 3)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 4
1 -1 0
2 -1 0
3 -1 0
4 -1 0
5 -1 0
6 -1 0
7 -1 0
[HIT:No Replacement] The byte value at memory address 03 is 41
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 09 (Base-10 value 9)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 4
1 -1 0
2 00 1
3 -1 0
4 -1 0
5 -1 0
6 -1 0
7 -1 0
[MISS:No Replacement] The byte value at memory address 09 is 32
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 0A (Base-10 value 10)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 4
1 -1 0
2 00 2
3 -1 0
4 -1 0
5 -1 0
6 -1 0
7 -1 0
[HIT:No Replacement] The byte value at memory address 0A is 53
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 0B (Base-10 value 11)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 4
1 -1 0
2 00 3
3 -1 0
4 -1 0
5 -1 0
6 -1 0
7 -1 0
[HIT:No Replacement] The byte value at memory address 0B is 7F
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 10 (Base-10 value 16)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 4
1 -1 0
2 00 3
3 -1 0
4 00 1
5 -1 0
6 -1 0
7 -1 0
[MISS:No Replacement] The byte value at memory address 10 is 68
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 20 (Base-10 value 32)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 01 1
1 -1 0
2 00 3
3 -1 0
4 00 1
5 -1 0
6 -1 0
7 -1 0
[MISS:Replacement] The byte value at memory address 20 is 7F
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 20 (Base-10 value 32)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 01 2
1 -1 0
2 00 3
3 -1 0
4 00 1
5 -1 0
6 -1 0
7 -1 0
[HIT:No Replacement] The byte value at memory address 20 is 7F
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 40 (Base-10 value 64)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 02 1
1 -1 0
2 00 3
3 -1 0
4 00 1
5 -1 0
6 -1 0
7 -1 0
[MISS:Replacement] The byte value at memory address 40 is 3A

236
lab-05/tests/directmapping_output1.txt Normal file
View File

@ -0,0 +1,236 @@
------------------------
[STEP 1] Setting up physical memory
------------------------
Physical memory addressable bits = 8, total number of blocks = 64
------------------------
[STEP 2] Determining physical memory block locations
------------------------
------------------------
[STEP 3] Select cache mapping function (CMF)
------------------------
1 = Direct mapping
2 = Fully associative
------------------------
Please enter 1 or 2:
------------------------
[STEP 4] initializing cache
------------------------
------------------------
[STEP 5] Starting simulation
------------------------
CMF is Direct Mapping
To exit simulation, press Ctrl+C
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 00 (Base-10 value 0)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 1
1 -1 0
2 -1 0
3 -1 0
4 -1 0
5 -1 0
6 -1 0
7 -1 0
[MISS:No Replacement] The byte value at memory address 00 is 7F
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 01 (Base-10 value 1)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 2
1 -1 0
2 -1 0
3 -1 0
4 -1 0
5 -1 0
6 -1 0
7 -1 0
[HIT:No Replacement] The byte value at memory address 01 is 24
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 01 (Base-10 value 1)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 3
1 -1 0
2 -1 0
3 -1 0
4 -1 0
5 -1 0
6 -1 0
7 -1 0
[HIT:No Replacement] The byte value at memory address 01 is 24
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 02 (Base-10 value 2)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 4
1 -1 0
2 -1 0
3 -1 0
4 -1 0
5 -1 0
6 -1 0
7 -1 0
[HIT:No Replacement] The byte value at memory address 02 is 7A
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 03 (Base-10 value 3)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 5
1 -1 0
2 -1 0
3 -1 0
4 -1 0
5 -1 0
6 -1 0
7 -1 0
[HIT:No Replacement] The byte value at memory address 03 is 41
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 05 (Base-10 value 5)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 5
1 00 1
2 -1 0
3 -1 0
4 -1 0
5 -1 0
6 -1 0
7 -1 0
[MISS:No Replacement] The byte value at memory address 05 is 7F
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 08 (Base-10 value 8)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 5
1 00 1
2 00 1
3 -1 0
4 -1 0
5 -1 0
6 -1 0
7 -1 0
[MISS:No Replacement] The byte value at memory address 08 is 33
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 0D (Base-10 value 13)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 5
1 00 1
2 00 1
3 00 1
4 -1 0
5 -1 0
6 -1 0
7 -1 0
[MISS:No Replacement] The byte value at memory address 0D is 67
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 15 (Base-10 value 21)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 5
1 00 1
2 00 1
3 00 1
4 -1 0
5 00 1
6 -1 0
7 -1 0
[MISS:No Replacement] The byte value at memory address 15 is 7F
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 22 (Base-10 value 34)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 01 1
1 00 1
2 00 1
3 00 1
4 -1 0
5 00 1
6 -1 0
7 -1 0
[MISS:Replacement] The byte value at memory address 22 is 7F
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 37 (Base-10 value 55)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 01 1
1 00 1
2 00 1
3 00 1
4 -1 0
5 01 1
6 -1 0
7 -1 0
[MISS:Replacement] The byte value at memory address 37 is 0D
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 59 (Base-10 value 89)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 01 1
1 00 1
2 00 1
3 00 1
4 -1 0
5 01 1
6 02 1
7 -1 0
[MISS:No Replacement] The byte value at memory address 59 is 68
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 90 (Base-10 value 144)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 01 1
1 00 1
2 00 1
3 00 1
4 04 1
5 01 1
6 02 1
7 -1 0
[MISS:No Replacement] The byte value at memory address 90 is 62
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address E9 (Base-10 value 233)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 01 1
1 00 1
2 07 1
3 00 1
4 04 1
5 01 1
6 02 1
7 -1 0
[MISS:Replacement] The byte value at memory address E9 is 7F

12
lab-05/tests/fullyassociative_input0.txt Normal file
View File

@ -0,0 +1,12 @@
2
00
01
02
03
09
0A
0B
10
20
20
40

15
lab-05/tests/fullyassociative_input1.txt Normal file
View File

@ -0,0 +1,15 @@
2
00
01
01
02
03
05
08
0d
15
22
37
59
90
e9

191
lab-05/tests/fullyassociative_output0.txt Normal file
View File

@ -0,0 +1,191 @@
------------------------
[STEP 1] Setting up physical memory
------------------------
Physical memory addressable bits = 8, total number of blocks = 64
------------------------
[STEP 2] Determining physical memory block locations
------------------------
------------------------
[STEP 3] Select cache mapping function (CMF)
------------------------
1 = Direct mapping
2 = Fully associative
------------------------
Please enter 1 or 2:
------------------------
[STEP 4] initializing cache
------------------------
------------------------
[STEP 5] Starting simulation
------------------------
CMF is Fully Associative
To exit simulation, press Ctrl+C
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 00 (Base-10 value 0)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 1
1 -1 0
2 -1 0
3 -1 0
4 -1 0
5 -1 0
6 -1 0
7 -1 0
[MISS:No Replacement] The byte value at memory address 00 is 7F
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 01 (Base-10 value 1)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 2
1 -1 0
2 -1 0
3 -1 0
4 -1 0
5 -1 0
6 -1 0
7 -1 0
[HIT:No Replacement] The byte value at memory address 01 is 24
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 02 (Base-10 value 2)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 3
1 -1 0
2 -1 0
3 -1 0
4 -1 0
5 -1 0
6 -1 0
7 -1 0
[HIT:No Replacement] The byte value at memory address 02 is 7A
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 03 (Base-10 value 3)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 4
1 -1 0
2 -1 0
3 -1 0
4 -1 0
5 -1 0
6 -1 0
7 -1 0
[HIT:No Replacement] The byte value at memory address 03 is 41
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 09 (Base-10 value 9)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 4
1 02 1
2 -1 0
3 -1 0
4 -1 0
5 -1 0
6 -1 0
7 -1 0
[MISS:No Replacement] The byte value at memory address 09 is 32
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 0A (Base-10 value 10)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 4
1 02 2
2 -1 0
3 -1 0
4 -1 0
5 -1 0
6 -1 0
7 -1 0
[HIT:No Replacement] The byte value at memory address 0A is 53
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 0B (Base-10 value 11)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 4
1 02 3
2 -1 0
3 -1 0
4 -1 0
5 -1 0
6 -1 0
7 -1 0
[HIT:No Replacement] The byte value at memory address 0B is 7F
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 10 (Base-10 value 16)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 4
1 02 3
2 04 1
3 -1 0
4 -1 0
5 -1 0
6 -1 0
7 -1 0
[MISS:No Replacement] The byte value at memory address 10 is 68
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 20 (Base-10 value 32)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 4
1 02 3
2 04 1
3 08 1
4 -1 0
5 -1 0
6 -1 0
7 -1 0
[MISS:No Replacement] The byte value at memory address 20 is 7F
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 20 (Base-10 value 32)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 4
1 02 3
2 04 1
3 08 2
4 -1 0
5 -1 0
6 -1 0
7 -1 0
[HIT:No Replacement] The byte value at memory address 20 is 7F
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 40 (Base-10 value 64)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 4
1 02 3
2 04 1
3 08 2
4 10 1
5 -1 0
6 -1 0
7 -1 0
[MISS:No Replacement] The byte value at memory address 40 is 3A

236
lab-05/tests/fullyassociative_output1.txt Normal file
View File

@ -0,0 +1,236 @@
------------------------
[STEP 1] Setting up physical memory
------------------------
Physical memory addressable bits = 8, total number of blocks = 64
------------------------
[STEP 2] Determining physical memory block locations
------------------------
------------------------
[STEP 3] Select cache mapping function (CMF)
------------------------
1 = Direct mapping
2 = Fully associative
------------------------
Please enter 1 or 2:
------------------------
[STEP 4] initializing cache
------------------------
------------------------
[STEP 5] Starting simulation
------------------------
CMF is Fully Associative
To exit simulation, press Ctrl+C
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 00 (Base-10 value 0)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 1
1 -1 0
2 -1 0
3 -1 0
4 -1 0
5 -1 0
6 -1 0
7 -1 0
[MISS:No Replacement] The byte value at memory address 00 is 7F
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 01 (Base-10 value 1)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 2
1 -1 0
2 -1 0
3 -1 0
4 -1 0
5 -1 0
6 -1 0
7 -1 0
[HIT:No Replacement] The byte value at memory address 01 is 24
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 01 (Base-10 value 1)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 3
1 -1 0
2 -1 0
3 -1 0
4 -1 0
5 -1 0
6 -1 0
7 -1 0
[HIT:No Replacement] The byte value at memory address 01 is 24
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 02 (Base-10 value 2)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 4
1 -1 0
2 -1 0
3 -1 0
4 -1 0
5 -1 0
6 -1 0
7 -1 0
[HIT:No Replacement] The byte value at memory address 02 is 7A
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 03 (Base-10 value 3)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 5
1 -1 0
2 -1 0
3 -1 0
4 -1 0
5 -1 0
6 -1 0
7 -1 0
[HIT:No Replacement] The byte value at memory address 03 is 41
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 05 (Base-10 value 5)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 5
1 01 1
2 -1 0
3 -1 0
4 -1 0
5 -1 0
6 -1 0
7 -1 0
[MISS:No Replacement] The byte value at memory address 05 is 7F
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 08 (Base-10 value 8)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 5
1 01 1
2 02 1
3 -1 0
4 -1 0
5 -1 0
6 -1 0
7 -1 0
[MISS:No Replacement] The byte value at memory address 08 is 33
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 0D (Base-10 value 13)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 5
1 01 1
2 02 1
3 03 1
4 -1 0
5 -1 0
6 -1 0
7 -1 0
[MISS:No Replacement] The byte value at memory address 0D is 67
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 15 (Base-10 value 21)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 5
1 01 1
2 02 1
3 03 1
4 05 1
5 -1 0
6 -1 0
7 -1 0
[MISS:No Replacement] The byte value at memory address 15 is 7F
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 22 (Base-10 value 34)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 5
1 01 1
2 02 1
3 03 1
4 05 1
5 08 1
6 -1 0
7 -1 0
[MISS:No Replacement] The byte value at memory address 22 is 7F
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 37 (Base-10 value 55)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 5
1 01 1
2 02 1
3 03 1
4 05 1
5 08 1
6 0D 1
7 -1 0
[MISS:No Replacement] The byte value at memory address 37 is 0D
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 59 (Base-10 value 89)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 5
1 01 1
2 02 1
3 03 1
4 05 1
5 08 1
6 0D 1
7 16 1
[MISS:No Replacement] The byte value at memory address 59 is 68
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address 90 (Base-10 value 144)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 5
1 24 1
2 02 1
3 03 1
4 05 1
5 08 1
6 0D 1
7 16 1
[MISS:Replacement] The byte value at memory address 90 is 62
Please enter 8-bit hexadecimal address: Entered Hexadecimal (Base-16) address E9 (Base-10 value 233)
---------------------------------------------
line tag num of hits
---------------------------------------------
0 00 5
1 3A 1
2 02 1
3 03 1
4 05 1
5 08 1
6 0D 1
7 16 1
[MISS:Replacement] The byte value at memory address E9 is 7F