guilhermewerner/tomasulo-simulator
1
0
Fork 0
mirror of https://github.com/guilhermewerner/tomasulo-simulator synced 2025-06-15 13:24:20 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge branch 'main' of https://github.com/GuilhermeWerner/Tomasulo

Browse Source
This commit is contained in:
Caio Eduardo Ramos Arães
2023-06-08 17:04:38 -03:00
parent 991b03cbad 6ab56eca23
commit 8d61353be0
1 changed files with 556 additions and 40 deletions
Download Patch File Download Diff File Expand all files Collapse all files

596
pages/index.js
View File

@ -11,28 +11,550 @@ import { useState } from 'react';
import Button from 'react-bootstrap/Button'; import Button from 'react-bootstrap/Button';
export default function Home() { export default function Home() {
const [clock, setClock] = useState(0); let baseI = {
const [instructionStatus, setInstructionStatus] = useState([]); issue: null,
const [reservationStations, setReservationStations] = useState([]); exeCompleta: null,
const [registerStatus, setRegisterStatus] = useState([]); write: null,
busy: false,
}
let instructions = [
{
posicao: 0,
instrucao: {
operacao: "LD",
registradorR: "F6",
registradorS: "32",
registradorT: "R1",
},
...baseI,
},
{
posicao: 1,
instrucao: {
operacao: "LD",
registradorR: "F2",
registradorS: "45",
registradorT: "R3",
},
...baseI,
},
{
posicao: 2,
instrucao: {
operacao: "MULTD",
registradorR: "F0",
registradorS: "F2",
registradorT: "F4",
},
...baseI,
},
{
posicao: 3,
instrucao: {
operacao: "SUBD",
registradorR: "F8",
registradorS: "F6",
registradorT: "F2",
},
...baseI,
},
{
posicao: 4,
instrucao: {
operacao: "DIVD",
registradorR: "F10",
registradorS: "F0",
registradorT: "F6",
},
...baseI,
},
{
posicao: 5,
instrucao: {
operacao: "ADDD",
registradorR: "F6",
registradorS: "F8",
registradorT: "F2",
},
...baseI,
}
];
let baseFu = {
instrucao: null,
estadoInstrucao: null,
tempo: null,
ocupado: false,
operacao: null,
vj: null,
vk: null,
qj: null,
qk: null,
};
let fUnites = [
{
tipoUnidade: "Integer",
nome: "Integer1",
...baseFu
},
{
tipoUnidade: "Integer",
nome: "Integer2",
...baseFu
},
{
tipoUnidade: "Integer",
nome: "Integer3",
...baseFu
},
{
tipoUnidade: "Add",
nome: "Add1",
...baseFu
},
{
tipoUnidade: "Add",
nome: "Add2",
...baseFu
},
{
tipoUnidade: "Add",
nome: "Add3",
...baseFu
},
{
tipoUnidade: "Mult",
nome: "Mult1",
...baseFu
},
{
tipoUnidade: "Mult",
nome: "Mult2",
...baseFu
}
];
let baseMu = {
instrucao: null,
estadoInstrucao: null,
tempo: null,
ocupado: false,
qi: null,
qj: null,
operacao: null,
endereco: null,
destino: null,
};
let mUnites = [
{
tipoUnidade: "Load",
nome: "Load1",
...baseMu
},
{
tipoUnidade: "Load",
nome: "Load2",
...baseMu
},
{
tipoUnidade: "Load",
nome: "Load3",
...baseMu
},
{
tipoUnidade: "Load",
nome: "Load4",
...baseMu
},
{
tipoUnidade: "Load",
nome: "Load5",
...baseMu
},
{
tipoUnidade: "Store",
nome: "Store1",
...baseMu
},
{
tipoUnidade: "Store",
nome: "Store2",
...baseMu
},
{
tipoUnidade: "Store",
nome: "Store3",
...baseMu
}
];
let [clock, setClock] = useState(0);
let [instructionStatus, setInstructionStatus] = useState(instructions);
let [functionalUnits, setFunctionalUnits] = useState(fUnites);
let [memoryUnits, setMmoryUnits] = useState(mUnites);
let [registerStatus, setRegisterStatus] = useState([]);
function fetchInstruction() {
for (let i = 0; i < instructionStatus.length; i++) {
let element = instructionStatus[i];
console.log("element:", element.instrucao.operacao);
if (element.issue === null) {
return element;
}
}
return undefined;
}
function getFunctionalUnity(instr) {
console.log("getFunctionalUnity:", instr.operacao);
switch (instr.operacao) {
case 'ADDD':
return 'Add'
case 'SUBD':
return 'Add'
case 'MULTD':
return 'Mult'
case 'DIVD':
return 'Mult'
case 'LD':
return 'Load'
case 'SD':
return 'Store'
case 'ADD':
return 'Integer'
case 'DADDUI':
return 'Integer'
case 'BEQ':
return 'Integer'
case 'BNEZ':
return 'Integer'
}
}
function getEmptyFunctionalUnity(tipoFU) {
if ((tipoFU === 'Load') || (tipoFU === 'Store')) {
for (let key in memoryUnits) {
var ufMem = memoryUnits[key];
if (ufMem.tipoUnidade === tipoFU) {
if (!ufMem.ocupado) {
return ufMem;
}
}
}
return undefined;
}
for (let key in functionalUnits) {
var uf = functionalUnits[key];
if (uf.tipoUnidade === tipoFU) {
if (!uf.ocupado) {
return uf;
}
}
}
return undefined;
}
function getCycles(instrucao) {
switch (instrucao.operacao) {
case 'ADDD':
return 1;
case 'SUBD':
return 1;
case 'MULTD':
return 1;
case 'DIVD':
return 1;
case 'LD':
return 1;
case 'SD':
return 1;
case 'ADD':
return 1;
case 'DADDUI':
return 1;
case 'BEQ':
return 1;
case 'BNEZ':
return 1;
}
}
function allocFunctionalUnit(uf, instrucao, estadoInstrucao) {
uf.instrucao = instrucao;
uf.estadoInstrucao = estadoInstrucao;
uf.tempo = getCycles(instrucao) + 1;
uf.ocupado = true;
uf.operacao = instrucao.operacao;
let reg_j;
let reg_k;
let reg_j_inst;
let reg_k_inst;
if ((instrucao.operacao === 'BNEZ') || (instrucao.operacao === 'BEQ')) {
reg_j = registerStatus[instrucao.registradorR];
reg_k = registerStatus[instrucao.registradorS];
reg_j_inst = instrucao.registradorR;
reg_k_inst = instrucao.registradorS;
} else {
reg_j = registerStatus[instrucao.registradorS];
reg_k = registerStatus[instrucao.registradorT];
reg_j_inst = instrucao.registradorS;
reg_k_inst = instrucao.registradorT;
}
if (reg_j === null || reg_j === undefined) {
uf.vj = reg_j_inst;
}
else {
if ((reg_j in functionalUnits) || (reg_j in memoryUnits)) {
uf.qj = reg_j;
}
else {
uf.vj = reg_j;
}
}
if (reg_k === null || reg_k === undefined) {
uf.vk = reg_k_inst;
}
else {
if ((reg_k in functionalUnits) || (reg_k in memoryUnits)) {
uf.qk = reg_k;
}
else {
uf.vk = reg_k;
}
}
}
function allocMemoryUnit(uf, instrucao, estadoInstrucao) {
uf.instrucao = instrucao;
uf.estadoInstrucao = estadoInstrucao;
uf.tempo = getCycles(instrucao) + 1
uf.ocupado = true;
uf.operacao = instrucao.operacao;
uf.endereco = instrucao.registradorS + '+' + instrucao.registradorT;
uf.destino = instrucao.registradorR;
uf.qi = null;
uf.qj = null;
if (instrucao.operacao === 'SD') {
let UFQueTemQueEsperar = registerStatus[instrucao.registradorR];
if ((UFQueTemQueEsperar in functionalUnits) || (UFQueTemQueEsperar in memoryUnits)) {
uf.qi = UFQueTemQueEsperar;
}
else {
uf.qi = null;
}
}
let UFintQueTemQueEsperar = registerStatus[instrucao.registradorT];
if ((UFintQueTemQueEsperar in functionalUnits) || (UFintQueTemQueEsperar in memoryUnits)) {
uf.qj = UFintQueTemQueEsperar;
}
else {
uf.qj = null;
}
}
function writeRegister(instrucao, ufNome) {
registerStatus[instrucao.registradorR] = ufNome;
setRegisterStatus(registerStatus);
}
function releaseWaitingUnity(UF) {
for (let keyUF in functionalUnits) {
const ufOlhando = functionalUnits[keyUF];
if ((ufOlhando.ocupado === true) && ((ufOlhando.qj === UF.nome) || (ufOlhando.qk === UF.nome))) {
if (ufOlhando.qj === UF.nome) {
ufOlhando.vj = 'VAL(' + UF.nome + ')';
ufOlhando.qj = null;
}
if (ufOlhando.qk === UF.nome) {
ufOlhando.vk = 'VAL(' + UF.nome + ')';
ufOlhando.qk = null;
}
if ((ufOlhando.qj === null) && (ufOlhando.qk === null)) {
ufOlhando.tempo = ufOlhando.tempo - 1;
}
}
}
for (let keyUF in memoryUnits) {
const ufOlhando = memoryUnits[keyUF];
if (ufOlhando.ocupado === true) {
if (ufOlhando.qi === UF.nome) {
ufOlhando.qi = null;
ufOlhando.tempo = ufOlhando.tempo - 1;
} else if (ufOlhando.qj === UF.nome) {
ufOlhando.qj = null;
ufOlhando.tempo = ufOlhando.tempo - 1;
}
}
}
}
function deallocFunctionalUnit(ufMem) {
ufMem.instrucao = null;
ufMem.estadoInstrucao = null;
ufMem.tempo = null;
ufMem.ocupado = false;
ufMem.operacao = null;
ufMem.endereco = null;
ufMem.destino = null;
ufMem.qi = null;
ufMem.qj = null;
}
function deallocMemorylUnit(uf) {
uf.instrucao = null;
uf.estadoInstrucao = null;
uf.tempo = null;
uf.ocupado = false;
uf.operacao = null;
uf.vj = null;
uf.vk = null;
uf.qj = null;
uf.qk = null;
}
function issueInstruction() { function issueInstruction() {
console.log("issueInstruction");
let novaInstrucao = fetchInstruction();
if (novaInstrucao) {
let ufInstrucao = getFunctionalUnity(novaInstrucao.instrucao);
let UFParaUsar = getEmptyFunctionalUnity(ufInstrucao);
if (UFParaUsar) {
if ((UFParaUsar.tipoUnidade == 'Load') || (UFParaUsar.tipoUnidade == 'Store')) {
allocMemoryUnit(UFParaUsar, novaInstrucao.instrucao, novaInstrucao);
}
else {
allocFunctionalUnit(UFParaUsar, novaInstrucao.instrucao, novaInstrucao);
}
novaInstrucao.issue = clock;
if ((UFParaUsar.tipoUnidade !== 'Store') && (UFParaUsar.operacao !== 'BEQ') && (UFParaUsar.operacao !== 'BEQ')) {
writeRegister(novaInstrucao.instrucao, UFParaUsar.nome);
}
}
}
} }
function executeInstruction() { function executeInstruction() {
for (let key in memoryUnits) {
var ufMem = memoryUnits[key];
if ((ufMem.ocupado) && (ufMem.qi === null) && (ufMem.qj === null)) {
ufMem.tempo = ufMem.tempo - 1;
console.log("estado Instrucao", ufMem.estadoInstrucao);
if (ufMem.tempo === 0) {
ufMem.estadoInstrucao.exeCompleta = clock;
ufMem.estadoInstrucao.busy = false;
}
}
}
for (let key in functionalUnits) {
var uf = functionalUnits[key];
if ((uf.ocupado) && (uf.vj !== null) && (uf.vk !== null)) {
uf.tempo = uf.tempo - 1;
uf.estadoInstrucao.busy = true;
if (uf.tempo === 0) {
uf.estadoInstrucao.exeCompleta = clock;
uf.estadoInstrucao.busy = false;
}
}
}
} }
function writeInstruction() { function writeInstruction() {
for (let key in memoryUnits) {
const ufMem = memoryUnits[key];
if (ufMem.ocupado) {
if (ufMem.tempo === -1) {
ufMem.estadoInstrucao.write = clock;
let valorReg = registerStatus[ufMem.instrucao.registradorR];
if (valorReg === ufMem.nome) {
registerStatus[ufMem.instrucao.registradorR] = 'VAL(' + ufMem.nome + ')';
}
releaseWaitingUnity(ufMem);
deallocMemorylUnit(ufMem);
}
}
}
for (let key in functionalUnits) {
const uf = functionalUnits[key];
if (uf.ocupado && uf.tempo === -1) {
uf.estadoInstrucao.write = clock;
let valorReg = registerStatus[uf.instrucao.registradorR];
if (valorReg === uf.nome) {
registerStatus[uf.instrucao.registradorR] = 'VAL(' + uf.nome + ')';
}
releaseWaitingUnity(uf);
deallocFunctionalUnit(uf);
}
}
} }
function nextCycle() { function nextCycle() {
setClock(clock + 1); setClock(clock + 1);
console.log(clock);
issueInstruction(); issueInstruction();
executeInstruction(); executeInstruction();
writeInstruction(); writeInstruction();
setInstructionStatus(instructionStatus);
setMmoryUnits(memoryUnits);
setFunctionalUnits(functionalUnits);
}
function getFormatedState(instr) {
if (instr.write !== null) {
return "Commit";
}
if (instr.exeCompleta !== null) {
return "Write Result";
}
if (instr.issue !== null) {
return "Execute";
}
return "Issue";
} }
return ( return (
@ -81,10 +603,10 @@ export default function Home() {
<tbody> <tbody>
{instructionStatus.map((instr, index) => ( {instructionStatus.map((instr, index) => (
<tr> <tr>
<td>batata</td> <td>{`${instr.instrucao.operacao} ${instr.instrucao.registradorR} ${instr.instrucao.registradorS} ${instr.instrucao.registradorT}`}</td>
<td>batata</td> <td>{instr.issue}</td>
<td>batata</td> <td>{instr.exeCompleta}</td>
<td>batata</td> <td>{instr.write}</td>
</tr> </tr>
))} ))}
</tbody> </tbody>
@ -108,12 +630,12 @@ export default function Home() {
<tbody> <tbody>
{instructionStatus.map((instr, index) => ( {instructionStatus.map((instr, index) => (
<tr> <tr>
<td>batata</td> <td>{instr.posicao}</td>
<td>batata</td> <td>{instr.busy ? "Yes" : "No"}</td>
<td>batata</td> <td>{`${instr.instrucao.operacao} ${instr.instrucao.registradorR} ${instr.instrucao.registradorS} ${instr.instrucao.registradorT}`}</td>
<td>batata</td> <td>{getFormatedState(instr)}</td>
<td>batata</td> <td>{instr.instrucao.registradorR}</td>
<td>batata</td> <td>Mem[{instr.instrucao.registradorS} + {instr.instrucao.registradorT}]</td>
</tr> </tr>
))} ))}
</tbody> </tbody>
@ -130,26 +652,20 @@ export default function Home() {
<thead> <thead>
<tr> <tr>
<th>Time</th> <th>Time</th>
<th>Name</th>
<th>Busy</th> <th>Busy</th>
<th>Op</th> <th>Address</th>
<th>Vj</th> <th>Destination</th>
<th>Vk</th>
<th>Qj</th>
<th>Qk</th>
<th>A</th>
</tr> </tr>
</thead> </thead>
<tbody> <tbody>
{reservationStations.map((instr, index) => ( {memoryUnits.map((unit, index) => (
<tr> <tr>
<td>batata</td> <td>{unit.tempo}</td>
<td>batata</td> <td>{unit.nome}</td>
<td>batata</td> <td>{unit.ocupado ? "Yes" : "No"}</td>
<td>batata</td> <td>{unit.endereco}</td>
<td>batata</td> <td>{unit.destino}</td>
<td>batata</td>
<td>batata</td>
<td>batata</td>
</tr> </tr>
))} ))}
</tbody> </tbody>
@ -162,6 +678,7 @@ export default function Home() {
<Table bordered hover> <Table bordered hover>
<thead> <thead>
<tr> <tr>
<th>Time</th>
<th>Name</th> <th>Name</th>
<th>Busy</th> <th>Busy</th>
<th>Op</th> <th>Op</th>
@ -169,20 +686,19 @@ export default function Home() {
<th>Vk</th> <th>Vk</th>
<th>Qj</th> <th>Qj</th>
<th>Qk</th> <th>Qk</th>
<th>A</th>
</tr> </tr>
</thead> </thead>
<tbody> <tbody>
{reservationStations.map((instr, index) => ( {functionalUnits.map((unit, index) => (
<tr> <tr>
<td>batata</td> <td>{unit.tempo}</td>
<td>batata</td> <td>{unit.nome}</td>
<td>batata</td> <td>{unit.ocupado ? "Yes" : "No"}</td>
<td>batata</td> <td>{unit.operacao}</td>
<td>batata</td> <td>{unit.vj}</td>
<td>batata</td> <td>{unit.vk}</td>
<td>batata</td> <td>{unit.qj}</td>
<td>batata</td> <td>{unit.qk}</td>
</tr> </tr>
))} ))}
</tbody> </tbody>
@ -240,7 +756,7 @@ export default function Home() {
</tr> </tr>
</tbody> </tbody>
</Table> </Table>
<div className="mt-auto text-center"> <div className="my-4 text-center">
<span className="text-muted">Caio Arâes, David Freitas, Guilherme Werner</span> <span className="text-muted">Caio Arâes, David Freitas, Guilherme Werner</span>
</div> </div>
</Container> </Container>