rushilwiz/lab-05-Rushilwiz
1
0
Fork 0
mirror of https://github.com/Comp211-SP24/lab-05-Rushilwiz.git synced 2025-04-03 03:50:16 -04:00
Code Issues Actions Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
github-classroom[bot] 2024-04-03 15:17:27 +00:00 committed by GitHub
commit 58eae3479f
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
19 changed files with 1969 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
.gitignore vendored Normal file
View File

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

25
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
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
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
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);

99
cache.c Normal file
View File

@ -0,0 +1,99 @@
// PID: 9DigitPidNoSpacesOrDashes
// 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) {
// TODO:
// 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))) {
// TODO: Part 1
} else if ((cmf == FA) && ((*hex_addr) < exp2(addr_bits))) {
// TODO: Part 2
}
// 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
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
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;
}

76
memory.c Normal file
View File

@ -0,0 +1,76 @@
// PID: 9DigitPidNoSpacesOrDashes
// 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) {
// TODO: Part 0
return 0;
}
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
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
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
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
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
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
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
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
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
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
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