This project is part of a Computer Architecture course which I have Undertaken at IIT-Roorkee. The Project seems very interesting to me and I will try my best to add further improvements to the project. I have tried to document the code as much as possible. You can find the references I used to make this project in the References folder.
For more details, you can check out the project details pdf at References.
While Explaining the working of different parts of the project, the following test code will be taken :
.data
number: .word 43
.text
main:
addi a1,a1,7
sw a1,34(x0)
loop:
addi a2,a2,7
beq a1,a2,shogo
skip:
addi x4,x4,9
shogo:
addi x5,x5,69
lw x9,34(x0)The Assembler Takes benefit of the patterns present in various instruction encodings. It creates tokens of the code and parses the tokens while analyzing the patterns present in them. This thus acts as a general instruction assembler.
To add more instructions in the assembler, simply add instructions along with the relevant data in the instructions.txt file like so :
bge 3 6 i12{11-11,9-4} rs2{5} rs1{5} funct3{101} i12{3-0,10-10} op{1100011}
add 3 6 funct7{0000000} rs2{5} rs1{5} funct3{000} rd{5} op{0110011}
sub 3 6 funct7{0100000} rs2{5} rs1{5} funct3{000} rd{5} op{0110011}
and 3 6 funct7{0000000} rs2{5} rs1{5} funct3{111} rd{5} op{0110011}
or 3 6 funct7{0000000} rs2{5} rs1{5} funct3{110} rd{5} op{0110011}
beq 3 6 i12{11-11,9-4} rs2{5} rs1{5} funct3{000} i12{3-0,10-10} op{1100011}
lw 3 5 i12{11-0} rs1{5} funct3{010} rd{5} op{0000011}
sw 3 6 i12{11-5} rs2{5} rs1{5} funct3{010} i12{4-0} op{0100011}
addi 3 5 i12{11-0} rs1{5} funct3{000} rd{5} op{0010011}
ori 3 5 i12{11-0} rs1{5} funct3{110} rd{5} op{0010011}
andi 3 5 i12{11-0} rs1{5} funct3{111} rd{5} op{0010011}Now to run the assembler, Simply clone the repo and run
cd phase1/part3
chmod +x run.sh
./run.sh assemblerTo generarte specific encodings, change the test.s file and then run the above code.
If everything runs properly, you should see something like this :
The Single Cycle Processor gets the machine encodings from the assembler and then iterates through them sequentially. To generate the control word, it uses the following Logic :
The control word consist of :
● RegRead
● ALUSrc
● ALUOp:
● MemWrite
● MemRead
● RegWrite
● Mem2Reg
● Branch and Jump
For Load Type Instructions : 1 1 00 0 1 1 1 0
For Store type Instructions : 1 1 00 1 0 0 0 0
For R-Type Instructions : 1 0 10 0 0 1 0 0
For Branch Type Instructions : 1 0 01 0 0 0 0 1
For I Type Instructions : 1 1 11 0 0 1 0 0
Apart from that it has functions , namely find_immediate_value, alu_control, do_alu_operation which does what the name intends.
To run the simulator, clone this repo and run
cd phase2
chmod +x run.sh
./run.sh simulatorIf everything runs correctly, you should get the following output :
In this Repo, you can find the following Implementations of 5-Stage PipeLine :
- Illusion of Pipeline By reversing the stages with stall Logic
- Implementation using Multi-Threading (Under Development)
- PipeLine with Operand-Forwarding,Support-For-Branch Instructions,Harvard Architecture and Reverse Execution
The Final PipeLine is the third one and it works by defining 4 intermediate pipeline registers :
ifid
idex
exmo
mowb
While the Illusion of PipeLine is made possible by the following code snippet :
for (int program_counter = 0; program_counter < instructionVector.size() + 4; program_counter++)
{
if (!program_counter_valid)
{
ifid = IFID();
idex = IDEX();
program_counter_valid = true;
}
{
if (program_counter < instructionVector.size())
{
FifthStage(mowb);
FourthStage(mowb, exmo, of);
ThirdStage(exmo, idex, of, program_counter_valid, program_counter, instructionVector.size());
SecondStage(idex, ifid, of);
FirstStage(ifid, instructionVector[program_counter], program_counter);
}
else
{
FifthStage(mowb);
FourthStage(mowb, exmo, of);
int temp1 = program_counter - extra_instructions;
ThirdStage(exmo, idex, of, program_counter_valid, temp1, instructionVector.size());
program_counter = temp1 + extra_instructions;
SecondStage(idex, ifid, of);
FirstStage(ifid, instructionVector[program_counter - extra_instructions], program_counter - extra_instructions);
extra_instructions++;
}
}
}As seen above, I have divided the Execution into 5 stages with each stage having some dependency on some register.
To run the simulator, clone this repository and run the following commands :
cd phase3
chmod +x run.sh
./run.sh pipelineIf everything runs correctly , you should see something like this :
Here I have implemented Write-Back Allocate Cache with LRU Replacement Policy.
The specs of the cache are as follows :
Implementation of Write-Back Allocate Cache Policy
Main Memory --> 64 X 64 array of integers
Cache Memory --> 4 sets, 2 ways, 64 blocks per cache line
Every Set will have to map 16 blocks of main memory, so we will have 16 tags per set
So if we ask for the data of :
TAG ---- INDEX ---- BLOCK OFFSET
9 ---- 2 ---- 10
Then in the main memory, this will map to -->
2*16 + 9 = 41st row of the main memory
and in that row, the 10th element.
This Simulation uses LRU replacement policy.
To make it more realsitic, each call to the main Memory makes the program stall by 1 second.
To run the cache, clone the repo and run :
cd phase4
cd Cache
chmod +x run.sh
./run.sh cacheIf everything runs correctly, you should see several main memory blocks and several Writes and Reads from the cache Like so :
In the Final Part of this Project, I integrated the cache with the 5 stage Pipeline and its working snippets are as follows :
The GUI is under active Development and will most likely be made using ImGui or Electronjs
Made with ❤️ By : shogo