From ff34ae129b4c4509005544cbbc74a4c41ae37f61 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=93scar=20Carrasco?= Date: Sun, 5 May 2024 12:00:01 +0100 Subject: [PATCH] chore: wip --- src/core/Common/Code.ts | 6 +- src/core/Common/CodeParser.ts | 623 ++++++++---------- src/core/Common/FunctionalUnit.ts | 121 ++-- src/core/Common/Instruction.ts | 223 +++---- src/core/Common/InstructionFormats.ts | 21 - src/core/Common/Machine.ts | 14 +- src/core/Common/Opcode.ts | 29 + src/core/Common/Opcodes.ts | 122 ---- src/core/Common/Register.ts | 9 +- src/core/Superscalar/Superscalar.ts | 50 +- src/core/VLIW/DependencyChecker.ts | 106 +-- src/core/VLIW/VLIW.ts | 48 +- src/core/VLIW/VLIWOperation.ts | 14 +- src/core/VLIW/VLIWParser.ts | 8 +- src/integration/superscalar-integration.ts | 30 +- src/integration/vliw-integration.ts | 30 +- src/interface/actions/table-actions.ts | 14 +- .../components/Superscalar/CodeComponent.tsx | 2 +- .../components/VLIW/InstructionComponent.tsx | 2 +- .../Superscalar/iteratelist.spec.ts | 10 +- 20 files changed, 650 insertions(+), 832 deletions(-) delete mode 100644 src/core/Common/InstructionFormats.ts create mode 100644 src/core/Common/Opcode.ts delete mode 100644 src/core/Common/Opcodes.ts diff --git a/src/core/Common/Code.ts b/src/core/Common/Code.ts index f4b13827..648bdf90 100644 --- a/src/core/Common/Code.ts +++ b/src/core/Common/Code.ts @@ -1,7 +1,7 @@ import { Instruction } from "./Instruction"; -import { CodeParser } from "./CodeParser"; -import { Machine } from "./Machine"; +import { parseProgram } from "./CodeParser"; +import { MACHINE_REGISTER_SIZE, MACHINE_MEMORY_SIZE } from "./Machine"; export class Code { private _lines: number; @@ -25,7 +25,7 @@ export class Code { } public load(input: string) { - let codeParsed = new CodeParser(input, Machine.NGP, Machine.MEMORY_SIZE); + const program = parseProgram(input, MACHINE_REGISTER_SIZE, MACHINE_MEMORY_SIZE); // First we need the number of code lines this._lines = codeParsed.lines; diff --git a/src/core/Common/CodeParser.ts b/src/core/Common/CodeParser.ts index 5315d671..3d6f61c4 100644 --- a/src/core/Common/CodeParser.ts +++ b/src/core/Common/CodeParser.ts @@ -1,381 +1,300 @@ import { type Token, - TokenError, - type TokenPosition, - alt_sc, apply, buildLexer, - expectEOF, - expectSingleResult, - opt_sc, + rule, rep_sc, - seq, + alt, + expectSingleResult, + expectEOF, + type TokenError, + kleft, + str, tok, + kright, + seq, } from "typescript-parsec"; -import { Instruction } from "./Instruction"; -import { Formats, FormatsNames } from "./InstructionFormats"; -import { OpcodesNames, opcodeToFormat } from "./Opcodes"; - -enum Tokens { - Inmediate = 0, - RegFP = 1, - RegGP = 2, - Id = 3, - Label = 4, - BraketOpen = 5, - BraketClose = 6, - Number = 7, - Comma = 8, - Space = 9, - NewLine = 10, - Comment = 11, +import type { OpcodeMnemonic, OpcodeType } from "./Opcode"; +import type { RegisterKind } from "./Register"; + +/* Tokens and tokenizer */ + +enum TokenKind { + Opcode = 0, + Register = 1, + Immediate = 2, + Label = 3, + Unsigned = 4, + OpenParen = 5, + CloseParen = 6, + Space = 7, + Comment = 8, } -enum RegType { - FP = 0, - GP = 1, -} -const RegTypeNames: string[] = ["FP", "GP"]; +type TokenType = Token; -interface Reg { - type: RegType; - pos: TokenPosition; - num: number; - text: string; -} +const tokenizer = buildLexer([ + [true, /^[A-Z]+g/, TokenKind.Opcode], + [true, /^[A-Z][0-9]+/g, TokenKind.Register], + [true, /^#[0-9]+/g, TokenKind.Immediate], + [true, /^[a-zA-Z_][a-zA-Z0-9_]*/g, TokenKind.Label], + [true, /^\d+/g, TokenKind.Unsigned], + [true, /^\(/g, TokenKind.OpenParen], + [true, /^\)/g, TokenKind.CloseParen], + [false, /^\s+/g, TokenKind.Space], + [false, /^[/][/][^\n]*\n/g, TokenKind.Comment], +]); -interface Address { - address: number; - reg: Reg; -} +/* AST definitions */ -interface OpcodeToken { - opcode: number; - pos: TokenPosition; +interface Opcode { + kind: `${Capitalize>}Opcode`; + mnemonic: T; } -const tokenizer = buildLexer([ - [true, /^#[+-]?[0-9]+/g, Tokens.Inmediate], - [true, /^[Ff][0-9]+/g, Tokens.RegFP], - [true, /^[Rr][0-9]+/g, Tokens.RegGP], - [true, /^[A-Za-z][A-Za-z0-9]*\:/g, Tokens.Label], - [true, /^[A-Za-z][A-Za-z0-9]*/g, Tokens.Id], - [true, /^\(/g, Tokens.BraketOpen], - [true, /^\)/g, Tokens.BraketClose], - [true, /^[+-]?[0-9]+/g, Tokens.Number], - [false, /^\,/g, Tokens.Comma], - [false, /^[ \t\v\f]+/g, Tokens.Space], - [false, /^\r?\n/g, Tokens.NewLine], - [false, /^\/\/.*\n/g, Tokens.Comment], -]); +interface Immediate { + kind: "Immediate"; + value: number; +} -const inmParser = apply( - tok(Tokens.Inmediate), - (num: Token) => { - return +num.text.slice(1); - }, -); +interface GenericRegister { + kind: `${T}Register`; + index: number; +} -const regParser = apply( - alt_sc(tok(Tokens.RegFP), tok(Tokens.RegGP)), - (reg: Token | Token) => { - let type = RegType.GP; - if (reg.kind === Tokens.RegFP) { - type = RegType.FP; - } - return { - type: type, - pos: reg.pos, - num: +reg.text.slice(1), - text: reg.text, - }; - }, -); +type GeneralPurposeRegister = GenericRegister; +type FloatingPointRegister = GenericRegister; -const addressParser = apply( - seq( - opt_sc(tok(Tokens.Number)), - tok(Tokens.BraketOpen), - regParser, - tok(Tokens.BraketClose), - ), - ( - address: [ - Token, - Token, - Reg, - Token, - ], - ) => { - if (address[2].type === RegType.FP) { - throw new TokenError( - address[2].pos, - "Address register cannot be FP register", - ); - } - return { address: address[0] ? +address[0].text : 0, reg: address[2] }; - }, -); +type Register = { + [T in RegisterKind]: GenericRegister; +}[RegisterKind]; -const opcodeParser = apply( - tok(Tokens.Id), - (opcodeTok: Token): OpcodeToken => { - const opcode: number = OpcodesNames.indexOf(opcodeTok.text); - if (opcode !== -1) { - return { opcode: opcode, pos: opcodeTok.pos }; - } - throw new TokenError(opcodeTok.pos, `Unknown opcode "${opcodeTok.text}".`); - }, -); +interface Label { + kind: "Label"; + name: string; +} -export class CodeParser { - private _instructions: Instruction[] = []; - private _labels: { [k: string]: number } = {}; +interface Addressing { + kind: "Addressing"; + offset: number; + address: number; +} - private _generalRegisters: number; - private _memorySize: number; +type Operand = Immediate | Register | Label | Addressing; - public get instructions(): Instruction[] { - return this._instructions; - } +type OperandSet = { + [Property in keyof T]: T[Property]; +}; - public get labels(): { [k: string]: number } { - return this._labels; - } - - public get lines(): number { - return this._instructions.length; - } +interface GenericInstruction { + kind: `${Capitalize>}Instruction`; + opcode: Opcode; + operands?: OperandSet; +} - constructor(code: string, generalRegisters: number, memorySize: number) { - this._generalRegisters = generalRegisters; - this._memorySize = memorySize; - this.parse(code); - } +type NopInstruction = GenericInstruction; + +type AddInstruction = GenericInstruction< + OpcodeMnemonic.ADD, + [GeneralPurposeRegister, GeneralPurposeRegister, GeneralPurposeRegister] +>; + +type AddiInstruction = GenericInstruction< + OpcodeMnemonic.ADDI, + [GeneralPurposeRegister, GeneralPurposeRegister, Immediate] +>; + +type SubInstruction = GenericInstruction< + OpcodeMnemonic.SUB, + [GeneralPurposeRegister, GeneralPurposeRegister, GeneralPurposeRegister] +>; + +type AddfInstruction = GenericInstruction< + OpcodeMnemonic.ADDF, + [FloatingPointRegister, FloatingPointRegister, FloatingPointRegister] +>; + +type SubfInstruction = GenericInstruction< + OpcodeMnemonic.SUBF, + [FloatingPointRegister, FloatingPointRegister, FloatingPointRegister] +>; + +type MultInstruction = GenericInstruction< + OpcodeMnemonic.MULT, + [GeneralPurposeRegister, GeneralPurposeRegister, GeneralPurposeRegister] +>; + +type MultfInstruction = GenericInstruction< + OpcodeMnemonic.MULTF, + [FloatingPointRegister, FloatingPointRegister, FloatingPointRegister] +>; + +type OrInstruction = GenericInstruction< + OpcodeMnemonic.OR, + [GeneralPurposeRegister, GeneralPurposeRegister, GeneralPurposeRegister] +>; + +type AndInstruction = GenericInstruction< + OpcodeMnemonic.AND, + [GeneralPurposeRegister, GeneralPurposeRegister, GeneralPurposeRegister] +>; + +type XorInstruction = GenericInstruction< + OpcodeMnemonic.XOR, + [GeneralPurposeRegister, GeneralPurposeRegister, GeneralPurposeRegister] +>; + +type NorInstruction = GenericInstruction< + OpcodeMnemonic.NOR, + [GeneralPurposeRegister, GeneralPurposeRegister, GeneralPurposeRegister] +>; + +type SllvInstruction = GenericInstruction< + OpcodeMnemonic.SLLV, + [GeneralPurposeRegister, GeneralPurposeRegister, GeneralPurposeRegister] +>; + +type SrlvInstruction = GenericInstruction< + OpcodeMnemonic.SRLV, + [GeneralPurposeRegister, GeneralPurposeRegister, GeneralPurposeRegister] +>; + +type LwInstruction = GenericInstruction< + OpcodeMnemonic.LW, + [GeneralPurposeRegister, Addressing] +>; + +type LfInstruction = GenericInstruction< + OpcodeMnemonic.LF, + [FloatingPointRegister, Addressing] +>; + +type SwInstruction = GenericInstruction< + OpcodeMnemonic.SW, + [GeneralPurposeRegister, Addressing] +>; + +type SfInstruction = GenericInstruction< + OpcodeMnemonic.SF, + [FloatingPointRegister, Addressing] +>; + +type BneInstruction = GenericInstruction< + OpcodeMnemonic.BNE, + [GeneralPurposeRegister, GeneralPurposeRegister, Label] +>; + +type BeqInstruction = GenericInstruction< + OpcodeMnemonic.BEQ, + [GeneralPurposeRegister, GeneralPurposeRegister, Label] +>; + +type BgtInstruction = GenericInstruction< + OpcodeMnemonic.BGT, + [GeneralPurposeRegister, GeneralPurposeRegister, Label] +>; + +type Instruction = + | NopInstruction + | AddInstruction + | AddiInstruction + | SubInstruction + | AddfInstruction + | SubfInstruction + | MultInstruction + | MultfInstruction + | OrInstruction + | AndInstruction + | XorInstruction + | NorInstruction + | SllvInstruction + | SrlvInstruction + | LwInstruction + | LfInstruction + | SwInstruction + | SfInstruction + | BneInstruction + | BeqInstruction + | BgtInstruction; + +interface LabelDefinition { + kind: "LabelDefinition"; + name: string; + lineNumber: number; +} - private parse(code: string) { - const result = expectSingleResult( - expectEOF(this.genCodeParser().parse(tokenizer.parse(code))), - ); +type Statement = Instruction | LabelDefinition; - // Create labels and instructions - let pos = 0; - for (let i = 0; i < result[1].length; i++) { - const line = result[1][i]; - if ("kind" in line && line.kind === Tokens.Label) { - const name = line.text.slice(0, -1); - if (name in this._labels) { - throw new Error( - `Error at instruction ${pos}, label ${line.text.slice( - 0, - -1, - )} already exists`, - ); - } - this._labels[name] = pos; - } else if (line instanceof Instruction) { - this._instructions.push(line); - pos++; - } else { - throw new Error(`Unexpected code parser fail: ${JSON.stringify(line)}`); - } - } - } +interface Program { + statements: Statement[]; +} - private genCodeParser() { - return seq( - opt_sc(tok(Tokens.Number)), - rep_sc(alt_sc(this.genOperationParser(), tok(Tokens.Label))), - ); +/* Parser implementation */ + +const applyRegister = ([registerPrefix, index]: [ + Token, + Immediate, +]): Register => { + switch (registerPrefix.text) { + case "R": + return { kind: "GeneralPurposeRegister", index: index.value }; + case "F": + return { kind: "FloatingPointRegister", index: index.value }; } - - private genOperationParser() { - return apply( - alt_sc( - seq(opcodeParser, regParser, regParser, regParser), - seq(opcodeParser, regParser, regParser, inmParser), - seq(opcodeParser, regParser, regParser, tok(Tokens.Id)), - seq(opcodeParser, regParser, addressParser), - opcodeParser, - ), // The order is important, the first succesfull match is the one that is returned - ( - operation: - | OpcodeToken - | [OpcodeToken, Reg, Reg, Reg] - | [OpcodeToken, Reg, Reg, number] - | [OpcodeToken, Reg, Address] - | [OpcodeToken, Reg, Reg, Token], - ) => { - let type: Formats; - const instruction: Instruction = new Instruction(); - let pos: TokenPosition; - - // set the opcode and get the current position - if (Array.isArray(operation)) { - instruction.opcode = operation[0].opcode; - pos = operation[0].pos; - } else { - instruction.opcode = operation.opcode; - pos = operation.pos; - } - - // Check the recived instruction format and set the operands - if (!Array.isArray(operation)) { - type = Formats.Noop; - } else if ("num" in operation[2] && operation.length === 4) { - if (operation[2].type !== operation[1].type) { - throw new TokenError( - operation[2].pos, - `Second operand register type(${ - RegTypeNames[operation[2].type] - }) mistmatch. Expected ${RegTypeNames[operation[1].type]}`, - ); - } - - if (typeof operation[3] === "number") { - type = Formats.GeneralRegisterAndInmediate; - - // Check that the registers are in bounds - if (operation[1].num > this._generalRegisters) { - throw new TokenError( - operation[1].pos, - "Destiny register number out of bounds", - ); - } - if (operation[2].num > this._generalRegisters) { - throw new TokenError( - operation[2].pos, - "Operand 1 register number out of bounds", - ); - } - - instruction.setOperand(0, operation[1].num, operation[1].text); - instruction.setOperand(1, operation[2].num, operation[2].text); - instruction.setOperand( - 2, - operation[3], - `#${operation[3].toString()}`, - ); - if (operation[1].type === RegType.FP) { - throw new TokenError( - operation[1].pos, - "Inmediate operand not allowed for floating point registers", - ); - } - } else if ("num" in operation[3]) { - if (operation[3].type !== operation[1].type) { - throw new TokenError( - operation[3].pos, - `Third operand register type(${ - RegTypeNames[operation[3].type] - }) mistmatch. Expected ${RegTypeNames[operation[1].type]}`, - ); - } - - if (operation[1].type === RegType.FP) { - type = Formats.TwoFloatingRegisters; - } else { - type = Formats.TwoGeneralRegisters; - } - - // Check that the registers are in bounds - if (operation[1].num > this._generalRegisters) { - throw new TokenError( - operation[1].pos, - "Destiny register number out of bounds", - ); - } - if (operation[2].num > this._generalRegisters) { - throw new TokenError( - operation[2].pos, - "Operand 1 register number out of bounds", - ); - } - if (operation[3].num > this._generalRegisters) { - throw new TokenError( - operation[3].pos, - "Operand 2 register number out of bounds", - ); - } - - instruction.setOperand(0, operation[1].num, operation[1].text); - instruction.setOperand(1, operation[2].num, operation[2].text); - instruction.setOperand(2, operation[3].num, operation[3].text); - } else if ("pos" in operation[3]) { - type = Formats.Jump; - - // Check that the registers are in bounds - if (operation[1].num > this._generalRegisters) { - throw new TokenError( - operation[1].pos, - "Operand 1 register number out of bounds", - ); - } - if (operation[2].num > this._generalRegisters) { - throw new TokenError( - operation[2].pos, - "Operand 2 register number out of bounds", - ); - } - - instruction.setOperand(0, operation[1].num, operation[1].text); - instruction.setOperand(1, operation[2].num, operation[2].text); - instruction.setOperand(2, undefined, operation[3].text); - } - } else if (operation.length === 3) { - if (operation[1].type === RegType.FP) { - type = Formats.FloatingLoadStore; - } else { - type = Formats.GeneralLoadStore; - } - - // Check that the registers are in bounds - if (operation[1].num > this._generalRegisters) { - throw new TokenError( - operation[1].pos, - "Destiny register number out of bounds", - ); - } - if (operation[2].reg.num > this._generalRegisters) { - throw new TokenError( - operation[2].reg.pos, - "Adress register number out of bounds", - ); - } - if (operation[2].address > this._memorySize) { - throw new TokenError( - operation[2].reg.pos, - "Memory address out of bounds", - ); - } - - instruction.setOperand(0, operation[1].num, operation[1].text); - instruction.setOperand( - 1, - operation[2].address, - operation[2].address.toString(), - ); - instruction.setOperand( - 2, - operation[2].reg.num, - `(${operation[2].reg.text})`, - ); - } - - const expectedType = opcodeToFormat(instruction.opcode); - if (type !== expectedType) { - throw new TokenError( - pos, - `Invalid instruction format for ${ - OpcodesNames[instruction.opcode] - }. Expected ${FormatsNames[expectedType]} format, got ${ - FormatsNames[type] - } format or similar`, - ); - } - - return instruction; - }, +}; + +const applyImmediate = (value: Token): Immediate => { + return { kind: "Immediate", value: +value.text }; +}; + +const applyLabel = (value: Token): Label => { + return { kind: "Label", name: value.text }; +}; + +const applyLabelDefinition = ( + value: Label, + [token, _]: [Token, Token], +): LabelDefinition => { + return { + kind: "LabelDefinition", + name: value.name, + lineNumber: token.pos.rowBegin, // TODO: test this + }; +}; + +const applyStatement = (value: Instruction | LabelDefinition): Statement => { + return value; +}; + +const applyProgram = (value: Statement[]): Program => { + return { + statements: value, + }; +}; + +export const REGISTER = rule(); +export const IMMEDIATE = rule(); +export const LABEL = rule(); +export const INSTR = rule(); +export const LABELDEF = rule(); +export const STAT = rule(); +export const PROGRAM = rule(); + +REGISTER.setPattern( + apply(seq(alt(str("R"), str("F")), IMMEDIATE), applyRegister), +); +IMMEDIATE.setPattern(apply(tok(TokenKind.Immediate), applyImmediate)); +LABEL.setPattern(apply(tok(TokenKind.Label), applyLabel)); +LABELDEF.setPattern(apply(kleft(LABEL, str(":")), applyLabelDefinition)); +STAT.setPattern(apply(alt(INSTR, LABELDEF), applyStatement)); +PROGRAM.setPattern(apply(rep_sc(STAT), applyProgram)); + +export const parseProgram = (programString: string): Program | TokenError => { + try { + return expectSingleResult( + expectEOF(PROGRAM.parse(tokenizer.parse(programString))), ); + } catch (e) { + return e; } -} +}; diff --git a/src/core/Common/FunctionalUnit.ts b/src/core/Common/FunctionalUnit.ts index 91494441..5d7a472e 100644 --- a/src/core/Common/FunctionalUnit.ts +++ b/src/core/Common/FunctionalUnit.ts @@ -1,16 +1,16 @@ -import { Instruction } from "./Instruction"; -import { Opcodes } from "./Opcodes"; +import type { Instruction } from "./Instruction"; +import type { Opcode } from "./Opcode"; -export enum FunctionalUnitType { +export enum FunctionalUnitKind { INTEGERSUM = 0, - INTEGERMULTIPLY, - FLOATINGSUM, - FLOATINGMULTIPLY, - MEMORY, - JUMP, + INTEGERMULTIPLY = 1, + FLOATINGSUM = 2, + FLOATINGMULTIPLY = 3, + MEMORY = 4, + JUMP = 5, } -export let FunctionalUnitTypeNames: string[] = [ +export const FunctionalUnitTypeNames: string[] = [ "Integer Sum", "Integer Multiply", "Floating Sum", @@ -20,7 +20,7 @@ export let FunctionalUnitTypeNames: string[] = [ ]; export const FUNCTIONALUNITTYPESQUANTITY = - FunctionalUnitType.JUMP - FunctionalUnitType.INTEGERSUM + 1; + FunctionalUnitKind.JUMP - FunctionalUnitKind.INTEGERSUM + 1; export interface FunctionalUntitVisualEntry { id: number; @@ -28,22 +28,22 @@ export interface FunctionalUntitVisualEntry { uid: number; } -const FunctionalUnitLantencies: Record = { - [FunctionalUnitType.INTEGERSUM]: 1, - [FunctionalUnitType.INTEGERMULTIPLY]: 2, - [FunctionalUnitType.FLOATINGSUM]: 4, - [FunctionalUnitType.FLOATINGMULTIPLY]: 6, - [FunctionalUnitType.MEMORY]: 4, - [FunctionalUnitType.JUMP]: 2, +const FunctionalUnitLantencies: Record = { + [FunctionalUnitKind.INTEGERSUM]: 1, + [FunctionalUnitKind.INTEGERMULTIPLY]: 2, + [FunctionalUnitKind.FLOATINGSUM]: 4, + [FunctionalUnitKind.FLOATINGMULTIPLY]: 6, + [FunctionalUnitKind.MEMORY]: 4, + [FunctionalUnitKind.JUMP]: 2, }; -export const FunctionalUnitNumbers: Record = { - [FunctionalUnitType.INTEGERSUM]: 2, - [FunctionalUnitType.INTEGERMULTIPLY]: 2, - [FunctionalUnitType.FLOATINGSUM]: 2, - [FunctionalUnitType.FLOATINGMULTIPLY]: 2, - [FunctionalUnitType.MEMORY]: 2, - [FunctionalUnitType.JUMP]: 1, +export const FunctionalUnitNumbers: Record = { + [FunctionalUnitKind.INTEGERSUM]: 2, + [FunctionalUnitKind.INTEGERMULTIPLY]: 2, + [FunctionalUnitKind.FLOATINGSUM]: 2, + [FunctionalUnitKind.FLOATINGMULTIPLY]: 2, + [FunctionalUnitKind.MEMORY]: 2, + [FunctionalUnitKind.JUMP]: 1, }; export interface FunctionalUnitResult { @@ -59,14 +59,14 @@ interface FunctionalUnitInstruction { } export class FunctionalUnit { - private _stalled: number = 0; // if >0, it is stalling (for ex because a memory fail) for that many cycles + private _stalled = 0; // if >0, it is stalling (for ex because a memory fail) for that many cycles private _instructions: FunctionalUnitInstruction[] = []; - private _nextRef: number = 0; //TODO: use instruction uid + private _nextRef = 0; //TODO: use instruction uid private _currentBlankTimeUnits: number; - private _hasExectutedInstBeforeTick: boolean = false; + private _hasExectutedInstBeforeTick = false; - public get type(): FunctionalUnitType { + public get type(): FunctionalUnitKind { return this._type; } @@ -79,7 +79,7 @@ export class FunctionalUnit { } constructor( - private _type: FunctionalUnitType, + private _type: FunctionalUnitKind, private _latency: number = FunctionalUnitLantencies[_type] ) { this._currentBlankTimeUnits = this._latency - 1; @@ -160,44 +160,44 @@ export class FunctionalUnit { // execute it let resul: number; switch (opcode) { - case Opcodes.ADD: - case Opcodes.ADDI: - case Opcodes.ADDF: + case OpcodeMnemonic.ADD: + case OpcodeMnemonic.ADDI: + case OpcodeMnemonic.ADDF: resul = firstValue + secondValue; break; - case Opcodes.SUB: - case Opcodes.SUBF: + case OpcodeMnemonic.SUB: + case OpcodeMnemonic.SUBF: resul = firstValue - secondValue; break; - case Opcodes.OR: + case OpcodeMnemonic.OR: resul = firstValue | secondValue; break; - case Opcodes.AND: + case OpcodeMnemonic.AND: resul = firstValue & secondValue; break; - case Opcodes.XOR: + case OpcodeMnemonic.XOR: resul = firstValue ^ secondValue; break; - case Opcodes.NOR: + case OpcodeMnemonic.NOR: resul = ~(firstValue | secondValue); break; - case Opcodes.SRLV: + case OpcodeMnemonic.SRLV: resul = firstValue >> secondValue; break; - case Opcodes.SLLV: + case OpcodeMnemonic.SLLV: resul = firstValue << secondValue; break; - case Opcodes.MULT: - case Opcodes.MULTF: + case OpcodeMnemonic.MULT: + case OpcodeMnemonic.MULTF: resul = firstValue * secondValue; break; - case Opcodes.BEQ: + case OpcodeMnemonic.BEQ: resul = firstValue === secondValue ? 1 : 0; break; - case Opcodes.BNE: + case OpcodeMnemonic.BNE: resul = firstValue !== secondValue ? 1 : 0; break; - case Opcodes.BGT: + case OpcodeMnemonic.BGT: resul = firstValue > secondValue ? 1 : 0; break; default: @@ -256,4 +256,35 @@ export class FunctionalUnit { return list; } + + public static newFromOpcode(opcode: Opcode) { + switch (opcode.mnemonic) { + case OpcodeMnemonic.ADD: + case OpcodeMnemonic.ADDI: + case OpcodeMnemonic.SUB: + case OpcodeMnemonic.OR: + case OpcodeMnemonic.AND: + case OpcodeMnemonic.NOR: + case OpcodeMnemonic.XOR: + case OpcodeMnemonic.SLLV: + case OpcodeMnemonic.SRLV: + return FunctionalUnitKind.INTEGERSUM; + case OpcodeMnemonic.ADDF: + case OpcodeMnemonic.SUBF: + return FunctionalUnitKind.FLOATINGSUM; + case OpcodeMnemonic.MULT: + return FunctionalUnitKind.INTEGERMULTIPLY; + case OpcodeMnemonic.MULTF: + return FunctionalUnitKind.FLOATINGMULTIPLY; + case OpcodeMnemonic.SW: + case OpcodeMnemonic.SF: + case OpcodeMnemonic.LW: + case OpcodeMnemonic.LF: + return FunctionalUnitKind.MEMORY; + case OpcodeMnemonic.BGT: + case OpcodeMnemonic.BNE: + case OpcodeMnemonic.BEQ: + return FunctionalUnitKind.JUMP; + } + } } diff --git a/src/core/Common/Instruction.ts b/src/core/Common/Instruction.ts index db016911..ef3fae43 100644 --- a/src/core/Common/Instruction.ts +++ b/src/core/Common/Instruction.ts @@ -1,90 +1,65 @@ -import { OpcodesNames, Opcodes } from "./Opcodes"; -import { FunctionalUnitType } from "./FunctionalUnit"; -import { opcodeToFunctionalUnit } from "./Opcodes"; +import { Opcode, OpcodeMnemonic } from "./Opcode"; -export class Instruction { - public id: number; - public basicBlock: number; - public opcode: number; - protected _operands: number[] = new Array(3); - protected _operandsString: string[] = new Array(3); - protected _label: string; - protected _breakPoint: boolean = false; - - public get uid(): number { - return this._uid; - } - public get breakPoint(): boolean { - return this._breakPoint; - } +export enum InstructionFormat { + TwoGeneralRegisters = 0, // OP R1, R2, R3 + TwoFloatingRegisters = 1, // OP F1, F2, F3 + GeneralRegisterAndInmediate = 2, // OP R1, R2, #X + GeneralLoadStore = 3, // OP R1, X(R2) + FloatingLoadStore = 4, // OP F1, X(R2) + Jump = 5, // OP R1, R2, label + Noop = 6, // NOP +} - public get operands(): number[] { - return this._operands; - } +interface Operand { + a: string; +} - public get label(): string { - return this._label; - } +export interface Instruction { - public set label(value: string) { - this._label = value; - } +} - public get operandsString(): string[] { - return this._operandsString; - } +export class Instruction { + readonly id: number; + readonly basicBlock: number; + readonly opcode: Opcode; + readonly operands: Operand[]; + readonly label: string; + readonly breakpoint = false; constructor(from?: Instruction, protected _uid?: number) { if (from) { this.id = from.id; this.basicBlock = from.basicBlock; this.opcode = from.opcode; - this._operands = from.operands.slice(); - this._operandsString = from.operandsString.slice(); - this._breakPoint = from.breakPoint; + this.operands = from.operands.slice(); + this.breakpoint = from.breakpoint; } } toString(): string { - let aux: string = ""; - if (this._operandsString[1]) { - aux += " " + this._operandsString[1]; - } - if (this._operandsString[2]) { - aux += " " + this._operandsString[2]; - } - return `${OpcodesNames[this.opcode]} ${this._operandsString[0]} ${aux}`; - } - - setOperand(index: number, value: number, valueString: string) { - this._operands[index] = value; - this.operandsString[index] = valueString; - } - - getOperand(index: number): number { - return this._operands[index]; + return `${this.opcode.mnemonic} ${this.operands}`; } /** * isJumpInstruction - this method checks if the instruction is a jump instruction */ public isJumpInstruction(): boolean { - return [Opcodes.BNE, Opcodes.BEQ, Opcodes.BGT].includes(this.opcode); + return [OpcodeMnemonic.BNE, OpcodeMnemonic.BEQ, OpcodeMnemonic.BGT].includes(this.opcode); } /** * isLoadInstruction - this method checks if the instruction that loads from memory */ public isLoadInstruction() { - return [Opcodes.LW, Opcodes.LF].includes(this.opcode); + return [OpcodeMnemonic.LW, OpcodeMnemonic.LF].includes(this.opcode); } /** * isStoreInstruction - this method checks if the instruction that stores from memory */ public isStoreInstruction(): boolean { - return [Opcodes.SF, Opcodes.SW].includes(this.opcode); + return [OpcodeMnemonic.SF, OpcodeMnemonic.SW].includes(this.opcode); } /** @@ -94,7 +69,7 @@ export class Instruction { return ( !this.isJumpInstruction() && !this.isStoreInstruction() && - ![Opcodes.NOP, Opcodes.OPERROR].includes(this.opcode) + ![OpcodeMnemonic.NOP, OpcodeMnemonic.OPERROR].includes(this.opcode) ); } @@ -103,11 +78,11 @@ export class Instruction { */ public isDestinyRegisterFloat(): boolean { return [ - Opcodes.ADDF, - Opcodes.SUBF, - Opcodes.MULTF, - Opcodes.LF, - Opcodes.SF, + OpcodeMnemonic.ADDF, + OpcodeMnemonic.SUBF, + OpcodeMnemonic.MULTF, + OpcodeMnemonic.LF, + OpcodeMnemonic.SF, ].includes(this.opcode); } @@ -116,21 +91,21 @@ export class Instruction { */ public getDestinyRegister(): number { switch (this.opcode) { - case Opcodes.ADD: - case Opcodes.SUB: - case Opcodes.MULT: - case Opcodes.OR: - case Opcodes.AND: - case Opcodes.NOR: - case Opcodes.XOR: - case Opcodes.SLLV: - case Opcodes.SRLV: - case Opcodes.ADDI: - case Opcodes.ADDF: - case Opcodes.SUBF: - case Opcodes.MULTF: - case Opcodes.LW: - case Opcodes.LF: + case OpcodeMnemonic.ADD: + case OpcodeMnemonic.SUB: + case OpcodeMnemonic.MULT: + case OpcodeMnemonic.OR: + case OpcodeMnemonic.AND: + case OpcodeMnemonic.NOR: + case OpcodeMnemonic.XOR: + case OpcodeMnemonic.SLLV: + case OpcodeMnemonic.SRLV: + case OpcodeMnemonic.ADDI: + case OpcodeMnemonic.ADDF: + case OpcodeMnemonic.SUBF: + case OpcodeMnemonic.MULTF: + case OpcodeMnemonic.LW: + case OpcodeMnemonic.LF: return this.operands[0]; default: return -1; @@ -141,7 +116,7 @@ export class Instruction { * isFirstOperandFloat */ public isFirstOperandFloat(): boolean { - return [Opcodes.ADDF, Opcodes.SUBF, Opcodes.MULTF, Opcodes.SF].includes( + return [OpcodeMnemonic.ADDF, OpcodeMnemonic.SUBF, OpcodeMnemonic.MULTF, OpcodeMnemonic.SF].includes( this.opcode ); } @@ -151,25 +126,25 @@ export class Instruction { */ public getFirstOperandRegister(): number { switch (this.opcode) { - case Opcodes.ADD: - case Opcodes.SUB: - case Opcodes.MULT: - case Opcodes.OR: - case Opcodes.AND: - case Opcodes.NOR: - case Opcodes.XOR: - case Opcodes.SLLV: - case Opcodes.SRLV: - case Opcodes.ADDI: - case Opcodes.ADDF: - case Opcodes.SUBF: - case Opcodes.MULTF: + case OpcodeMnemonic.ADD: + case OpcodeMnemonic.SUB: + case OpcodeMnemonic.MULT: + case OpcodeMnemonic.OR: + case OpcodeMnemonic.AND: + case OpcodeMnemonic.NOR: + case OpcodeMnemonic.XOR: + case OpcodeMnemonic.SLLV: + case OpcodeMnemonic.SRLV: + case OpcodeMnemonic.ADDI: + case OpcodeMnemonic.ADDF: + case OpcodeMnemonic.SUBF: + case OpcodeMnemonic.MULTF: return this.operands[1]; - case Opcodes.SW: - case Opcodes.SF: - case Opcodes.BEQ: - case Opcodes.BNE: - case Opcodes.BGT: + case OpcodeMnemonic.SW: + case OpcodeMnemonic.SF: + case OpcodeMnemonic.BEQ: + case OpcodeMnemonic.BNE: + case OpcodeMnemonic.BGT: return this.operands[0]; default: return -1; @@ -180,7 +155,7 @@ export class Instruction { * isSecondOperandFloat */ public isSecondOperandFloat(): boolean { - return [Opcodes.ADDF, Opcodes.SUBF, Opcodes.MULTF].includes(this.opcode); + return [OpcodeMnemonic.ADDF, OpcodeMnemonic.SUBF, OpcodeMnemonic.MULTF].includes(this.opcode); } /** @@ -188,26 +163,26 @@ export class Instruction { */ public getSecondOperandRegister(): number { switch (this.opcode) { - case Opcodes.ADD: - case Opcodes.SUB: - case Opcodes.MULT: - case Opcodes.OR: - case Opcodes.AND: - case Opcodes.NOR: - case Opcodes.XOR: - case Opcodes.SLLV: - case Opcodes.SRLV: - case Opcodes.ADDF: - case Opcodes.SUBF: - case Opcodes.MULTF: - case Opcodes.SW: - case Opcodes.SF: - case Opcodes.LW: - case Opcodes.LF: + case OpcodeMnemonic.ADD: + case OpcodeMnemonic.SUB: + case OpcodeMnemonic.MULT: + case OpcodeMnemonic.OR: + case OpcodeMnemonic.AND: + case OpcodeMnemonic.NOR: + case OpcodeMnemonic.XOR: + case OpcodeMnemonic.SLLV: + case OpcodeMnemonic.SRLV: + case OpcodeMnemonic.ADDF: + case OpcodeMnemonic.SUBF: + case OpcodeMnemonic.MULTF: + case OpcodeMnemonic.SW: + case OpcodeMnemonic.SF: + case OpcodeMnemonic.LW: + case OpcodeMnemonic.LF: return this.operands[2]; - case Opcodes.BEQ: - case Opcodes.BNE: - case Opcodes.BGT: + case OpcodeMnemonic.BEQ: + case OpcodeMnemonic.BNE: + case OpcodeMnemonic.BGT: return this.operands[1]; default: @@ -220,14 +195,14 @@ export class Instruction { */ public getAddressOperand(): number { switch (this.opcode) { - case Opcodes.SW: - case Opcodes.SF: - case Opcodes.LW: - case Opcodes.LF: + case OpcodeMnemonic.SW: + case OpcodeMnemonic.SF: + case OpcodeMnemonic.LW: + case OpcodeMnemonic.LF: return this.operands[1]; - case Opcodes.BEQ: - case Opcodes.BNE: - case Opcodes.BGT: + case OpcodeMnemonic.BEQ: + case OpcodeMnemonic.BNE: + case OpcodeMnemonic.BGT: return this.operands[2]; default: return -1; @@ -238,21 +213,21 @@ export class Instruction { * hasImmediateOperand - this method checks if the instruction has an immediate operand */ public hasImmediateOperand(): boolean { - return this.opcode === Opcodes.ADDI; + return this.opcode === OpcodeMnemonic.ADDI; } /** * getImmediateOperand - this method returns the immediate operand of the instruction or -1 if it doesn't have one */ public getImmediateOperand(): number { - return this.opcode === Opcodes.ADDI ? this.operands[2] : -1; + return this.opcode === OpcodeMnemonic.ADDI ? this.operands[2] : -1; } public toggleBreakPoint() { - this._breakPoint = !this._breakPoint; + this.breakpoint = !this.breakpoint; } - public getFunctionalUnitType(): FunctionalUnitType { + public getFunctionalUnitType(): FunctionalUnitKind { return opcodeToFunctionalUnit(this.opcode); } } diff --git a/src/core/Common/InstructionFormats.ts b/src/core/Common/InstructionFormats.ts deleted file mode 100644 index 1bd5dbf5..00000000 --- a/src/core/Common/InstructionFormats.ts +++ /dev/null @@ -1,21 +0,0 @@ -import { Opcodes } from "./Opcodes"; - -export enum Formats { - TwoGeneralRegisters = 0, // OP R1, R2, R3 - TwoFloatingRegisters, // OP F1, F2, F3 - GeneralRegisterAndInmediate, // OP R1, R2, #X - GeneralLoadStore, // OP R1, X(R2) - FloatingLoadStore, // OP F1, X(R2) - Jump, // OP R1, R2, label - Noop, // NOP -} - -export let FormatsNames: string[] = [ - "TwoGeneralRegisters", - "TwoFloatingRegisters", - "GeneralRegisterAndInmediate", - "GeneralLoadStore", - "FloatingLoadStore", - "Jump", - "Noop", -]; diff --git a/src/core/Common/Machine.ts b/src/core/Common/Machine.ts index 91006462..8e017285 100644 --- a/src/core/Common/Machine.ts +++ b/src/core/Common/Machine.ts @@ -2,14 +2,14 @@ import { Register } from "./Register"; import { FunctionalUnit, FUNCTIONALUNITTYPESQUANTITY, - FunctionalUnitType, + type FunctionalUnitKind, FunctionalUnitNumbers, } from "./FunctionalUnit"; -import { Cache } from "./Cache"; +import type { Cache } from "./Cache"; import { Memory } from "./Memory"; -const MACHINE_REGISTER_SIZE = 64; -const MACHINE_MEMORY_SIZE = 1024; +export const MACHINE_REGISTER_SIZE = 64; +export const MACHINE_MEMORY_SIZE = 1024; const MACHINE_MEMORY_FAIL_LATENCY = 9; export interface MachineStatus { @@ -156,10 +156,10 @@ export class Machine { } public changeFunctionalUnitLatency( - type: FunctionalUnitType, + type: FunctionalUnitKind, latency: number ) { - if (latency == 0) { + if (latency === 0) { return; } @@ -168,7 +168,7 @@ export class Machine { } } - public changeFunctionalUnitNumber(type: FunctionalUnitType, num: number) { + public changeFunctionalUnitNumber(type: FunctionalUnitKind, num: number) { if (num === 0) { return; } diff --git a/src/core/Common/Opcode.ts b/src/core/Common/Opcode.ts new file mode 100644 index 00000000..5ba8f6ab --- /dev/null +++ b/src/core/Common/Opcode.ts @@ -0,0 +1,29 @@ +export enum OpcodeMnemonic { + NOP = "NOP", + ADD = "ADD", + ADDI = "ADDI", + SUB = "SUB", + ADDF = "ADDF", + SUBF = "SUBF", + MULT = "MULT", + MULTF = "MULTF", + OR = "OR", + AND = "AND", + XOR = "XOR", + NOR = "NOR", + SLLV = "SLLV", + SRLV = "SRLV", + LW = "LW", + LF = "LF", + SW = "SW", + SF = "SF", + BNE = "BNE", + BEQ = "BEQ", + BGT = "BGT", +} + +export type OpcodeType = `${OpcodeMnemonic}`; + +export interface Opcode { + mnemonic: OpcodeMnemonic; +} diff --git a/src/core/Common/Opcodes.ts b/src/core/Common/Opcodes.ts deleted file mode 100644 index b0dbb3d1..00000000 --- a/src/core/Common/Opcodes.ts +++ /dev/null @@ -1,122 +0,0 @@ -import { FunctionalUnitType } from "./FunctionalUnit"; -import { Formats } from "./InstructionFormats"; - -export enum Opcodes { - NOP = 0, - ADD, - ADDI, - SUB, - ADDF, - SUBF, - MULT, - MULTF, - OR, - AND, - XOR, - NOR, - SLLV, - SRLV, - SW, - SF, - LW, - LF, - BNE, - BEQ, - BGT, - OPERROR, -} - -export let OpcodesNames: string[] = [ - "NOP", - "ADD", - "ADDI", - "SUB", - "ADDF", - "SUBF", - "MULT", - "MULTF", - "OR", - "AND", - "XOR", - "NOR", - "SLLV", - "SRLV", - "SW", - "SF", - "LW", - "LF", - "BNE", - "BEQ", - "BGT", -]; - -export function opcodeToFunctionalUnit(opcode: Opcodes): FunctionalUnitType { - switch (opcode) { - case Opcodes.ADD: - case Opcodes.ADDI: - case Opcodes.SUB: - case Opcodes.OR: - case Opcodes.AND: - case Opcodes.NOR: - case Opcodes.XOR: - case Opcodes.SLLV: - case Opcodes.SRLV: - return FunctionalUnitType.INTEGERSUM; - case Opcodes.ADDF: - case Opcodes.SUBF: - return FunctionalUnitType.FLOATINGSUM; - case Opcodes.MULT: - return FunctionalUnitType.INTEGERMULTIPLY; - case Opcodes.MULTF: - return FunctionalUnitType.FLOATINGMULTIPLY; - case Opcodes.SW: - case Opcodes.SF: - case Opcodes.LW: - case Opcodes.LF: - return FunctionalUnitType.MEMORY; - case Opcodes.BGT: - case Opcodes.BNE: - case Opcodes.BEQ: - return FunctionalUnitType.JUMP; - default: - throw new Error( - "Error at opcodeToFunctionalUnit, unknown opcode : " + - OpcodesNames[opcode] - ); - } -} - -export function opcodeToFormat(opcode: Opcodes): Formats { - switch (opcode) { - case Opcodes.NOP: - return Formats.Noop; - case Opcodes.ADD: - case Opcodes.SUB: - case Opcodes.MULT: - case Opcodes.OR: - case Opcodes.AND: - case Opcodes.XOR: - case Opcodes.NOR: - case Opcodes.SLLV: - case Opcodes.SRLV: - return Formats.TwoGeneralRegisters; - case Opcodes.ADDF: - case Opcodes.SUBF: - case Opcodes.MULTF: - return Formats.TwoFloatingRegisters; - case Opcodes.ADDI: - return Formats.GeneralRegisterAndInmediate; - case Opcodes.SW: - case Opcodes.LW: - return Formats.GeneralLoadStore; - case Opcodes.SF: - case Opcodes.LF: - return Formats.FloatingLoadStore; - case Opcodes.BNE: - case Opcodes.BEQ: - case Opcodes.BGT: - return Formats.Jump; - default: - throw new Error("Invalid opcode: " + opcode); - } -} diff --git a/src/core/Common/Register.ts b/src/core/Common/Register.ts index 3854afb9..2f156b7e 100644 --- a/src/core/Common/Register.ts +++ b/src/core/Common/Register.ts @@ -1,3 +1,10 @@ +export enum RegisterKind { + GeneralPurpose = "GeneralPurpose", + FloatingPoint = "FloatingPoint" +} + +export type RegisterType = `${RegisterKind}`; + export class Register { private _content: number[]; private _bufferIn: number[]; @@ -13,7 +20,7 @@ export class Register { constructor( private _numberOfRegs: number, - private _zeroWritable: boolean = false + private _zeroWritable = false ) { this._busy = new Array(_numberOfRegs); this._content = new Array(_numberOfRegs); diff --git a/src/core/Superscalar/Superscalar.ts b/src/core/Superscalar/Superscalar.ts index 8b7236da..c6935217 100644 --- a/src/core/Superscalar/Superscalar.ts +++ b/src/core/Superscalar/Superscalar.ts @@ -6,7 +6,7 @@ import { PrefetchUnit } from "./PrefetchUnit"; import { ReserveStation } from "./ReserveStation"; import { FunctionalUnit, - FunctionalUnitType, + FunctionalUnitKind, FunctionalUnitNumbers, FUNCTIONALUNITTYPESQUANTITY, } from "../Common/FunctionalUnit"; @@ -27,7 +27,7 @@ export class Superscalar extends Machine { private _issue: number; private _code: Code; - private _reserveStations: Map; + private _reserveStations: Map; private _reorderBuffer: ReorderBuffer; private _prefetchUnit: PrefetchUnit; private _decoder: PrefetchUnit; @@ -83,7 +83,7 @@ export class Superscalar extends Machine { this.issue = Superscalar.ISSUE_DEF; this._jumpPrediction = new JumpPredictor(Superscalar.PREDTABLESIZE); - this._reserveStations = new Map(); + this._reserveStations = new Map(); let total = 0; // total ROB size for (let i = 0; i < FUNCTIONALUNITTYPESQUANTITY; i++) { let size = this.getReserveStationSize(i); @@ -96,53 +96,53 @@ export class Superscalar extends Machine { this._code = null; - this._aluMem = new Array(FunctionalUnitNumbers[FunctionalUnitType.MEMORY]); + this._aluMem = new Array(FunctionalUnitNumbers[FunctionalUnitKind.MEMORY]); - for (let j = 0; j < FunctionalUnitNumbers[FunctionalUnitType.MEMORY]; j++) { - this.aluMem[j] = new FunctionalUnit(FunctionalUnitType.INTEGERSUM); + for (let j = 0; j < FunctionalUnitNumbers[FunctionalUnitKind.MEMORY]; j++) { + this.aluMem[j] = new FunctionalUnit(FunctionalUnitKind.INTEGERSUM); } this._currentCommitedInstrs = new Array(); } public changeFunctionalUnitLatency( - type: FunctionalUnitType, + type: FunctionalUnitKind, latency: number ) { super.changeFunctionalUnitLatency(type, latency); // Update the latency of the alu mem if the type is interger sum (same type of unit) - if (type === FunctionalUnitType.INTEGERSUM) { + if (type === FunctionalUnitKind.INTEGERSUM) { for (let j = 0; j < this.aluMem.length; j++) { this.aluMem[j] = new FunctionalUnit( - FunctionalUnitType.INTEGERSUM, + FunctionalUnitKind.INTEGERSUM, latency ); } } } - public changeFunctionalUnitNumber(type: FunctionalUnitType, num: number) { + public changeFunctionalUnitNumber(type: FunctionalUnitKind, num: number) { super.changeFunctionalUnitNumber(type, num); // Update the number of alu mem units acortding to the number of memory units - if (type === FunctionalUnitType.MEMORY) { + if (type === FunctionalUnitKind.MEMORY) { let currentLatency = this.aluMem[0].latency; this._aluMem = new Array(num); for (let j = 0; j < num; j++) { this.aluMem[j] = new FunctionalUnit( - FunctionalUnitType.INTEGERSUM, + FunctionalUnitKind.INTEGERSUM, currentLatency ); } } } - public getReserveStation(type: FunctionalUnitType): ReserveStation { + public getReserveStation(type: FunctionalUnitKind): ReserveStation { return this._reserveStations[type]; } - public getReserveStationSize(type: FunctionalUnitType): number { + public getReserveStationSize(type: FunctionalUnitKind): number { return ( this.functionalUnit[type].length * (this.functionalUnit[type][0].latency + 1) @@ -355,7 +355,7 @@ export class Superscalar extends Machine { ticIssue() { while (!this._decoder.isEmpty()) { - let fuType: FunctionalUnitType = this.code.getFunctionalUnitType( + let fuType: FunctionalUnitKind = this.code.getFunctionalUnitType( this._decoder.getId() ); @@ -377,7 +377,7 @@ export class Superscalar extends Machine { } } - executeInstruction(type: FunctionalUnitType, num: number) { + executeInstruction(type: FunctionalUnitKind, num: number) { let readyInstsRefs = this._reserveStations[type].getReadyInstructions(); for (let instrUID of readyInstsRefs) { let instruction = this._reorderBuffer.getInstruction(instrUID); @@ -427,17 +427,17 @@ export class Superscalar extends Machine { // if an instruction is ready, write the result address to the reorder buffer and reserve station let instrUid = execution.instruction.uid; let baseAddress = - this._reserveStations[FunctionalUnitType.MEMORY].getAddressOperand( + this._reserveStations[FunctionalUnitKind.MEMORY].getAddressOperand( instrUid ); let offset = this._reserveStations[ - FunctionalUnitType.MEMORY + FunctionalUnitKind.MEMORY ].getSecondOperandValue(instrUid); let address = baseAddress + offset; this._reorderBuffer.writeResultAddress(instrUid, address); - this._reserveStations[FunctionalUnitType.MEMORY].setAddressOperand( + this._reserveStations[FunctionalUnitKind.MEMORY].setAddressOperand( instrUid, address ); @@ -449,7 +449,7 @@ export class Superscalar extends Machine { // Go again through all the memory reserve stations but this time sending the instructions to the address ALU for (let i = 0; i < this.aluMem.length; i++) { let readyInstsRefs = - this._reserveStations[FunctionalUnitType.MEMORY].getReadyInstructions( + this._reserveStations[FunctionalUnitKind.MEMORY].getReadyInstructions( true ); // we dont need the first operand ready, as we are only calculating the address for (let instrUID of readyInstsRefs) { @@ -464,7 +464,7 @@ export class Superscalar extends Machine { // so their address can be calculated this.aluMem[i].addInstruction(instruction); this._reserveStations[ - FunctionalUnitType.MEMORY + FunctionalUnitKind.MEMORY ].associateAddressALU(instrUID, i); this._reorderBuffer.executeInstruction(instrUID); break; @@ -474,7 +474,7 @@ export class Superscalar extends Machine { } } - writeInstruction(type: FunctionalUnitType, num: number) { + writeInstruction(type: FunctionalUnitKind, num: number) { let resul; let instUid = this.functionalUnit[type][num].getReadyInstructionUid(); if (instUid !== -1) { @@ -538,7 +538,7 @@ export class Superscalar extends Machine { // so here we are doing the execution stage of the stores. And also, we are writing the result of all the stores at the same time with no limits // why? because potatos let readyLoadsRefs = - this._reserveStations[FunctionalUnitType.MEMORY].getReadyInstructions(); + this._reserveStations[FunctionalUnitKind.MEMORY].getReadyInstructions(); let refsToRemove = new Array(); for (let instrUID of readyLoadsRefs) { let instruction = this._reorderBuffer.getInstruction(instrUID); @@ -552,7 +552,7 @@ export class Superscalar extends Machine { // write the result to the ROB and remove the instruction from the reserve station this._reorderBuffer.writeResultValue( instrUID, - this._reserveStations[FunctionalUnitType.MEMORY].getFirstOperandValue( + this._reserveStations[FunctionalUnitKind.MEMORY].getFirstOperandValue( instrUID ) ); @@ -561,7 +561,7 @@ export class Superscalar extends Machine { } } for (let instrRef of refsToRemove) { - this._reserveStations[FunctionalUnitType.MEMORY].removeInstruction( + this._reserveStations[FunctionalUnitKind.MEMORY].removeInstruction( instrRef ); } diff --git a/src/core/VLIW/DependencyChecker.ts b/src/core/VLIW/DependencyChecker.ts index ce0562c5..47072c88 100644 --- a/src/core/VLIW/DependencyChecker.ts +++ b/src/core/VLIW/DependencyChecker.ts @@ -1,6 +1,6 @@ -import { Opcodes } from '../Common/Opcodes'; +import { OpcodeMnemonic } from '../Common/Opcode'; import { VLIWOperation } from './VLIWOperation'; -import { FunctionalUnitType } from '../Common/FunctionalUnit'; +import { FunctionalUnitKind } from '../Common/FunctionalUnit'; export interface Check { latency: number; @@ -11,104 +11,104 @@ export class DependencyChecker { public static checkTargetOperation(operation: VLIWOperation, checkGPR: Check[], checkFPR: Check[], functionalUnitLatencies: number[]) { switch (operation.opcode) { - case Opcodes.ADD: - case Opcodes.ADDI: - if (checkGPR[operation.getOperand(0)].latency < functionalUnitLatencies[FunctionalUnitType.INTEGERSUM]) { - checkGPR[operation.getOperand(0)].latency = functionalUnitLatencies[FunctionalUnitType.INTEGERSUM]; + case OpcodeMnemonic.ADD: + case OpcodeMnemonic.ADDI: + if (checkGPR[operation.getOperand(0)].latency < functionalUnitLatencies[FunctionalUnitKind.INTEGERSUM]) { + checkGPR[operation.getOperand(0)].latency = functionalUnitLatencies[FunctionalUnitKind.INTEGERSUM]; checkGPR[operation.getOperand(0)].register = operation.id; } break; - case Opcodes.MULT: - if (checkGPR[operation.getOperand(0)].latency < functionalUnitLatencies[FunctionalUnitType.INTEGERMULTIPLY]) { - checkGPR[operation.getOperand(0)].latency = functionalUnitLatencies[FunctionalUnitType.INTEGERMULTIPLY]; + case OpcodeMnemonic.MULT: + if (checkGPR[operation.getOperand(0)].latency < functionalUnitLatencies[FunctionalUnitKind.INTEGERMULTIPLY]) { + checkGPR[operation.getOperand(0)].latency = functionalUnitLatencies[FunctionalUnitKind.INTEGERMULTIPLY]; checkGPR[operation.getOperand(0)].register = operation.id; } break; - case Opcodes.ADDF: - if (checkFPR[operation.getOperand(0)].latency < functionalUnitLatencies[FunctionalUnitType.FLOATINGSUM]) { - checkFPR[operation.getOperand(0)].latency = functionalUnitLatencies[FunctionalUnitType.FLOATINGSUM]; + case OpcodeMnemonic.ADDF: + if (checkFPR[operation.getOperand(0)].latency < functionalUnitLatencies[FunctionalUnitKind.FLOATINGSUM]) { + checkFPR[operation.getOperand(0)].latency = functionalUnitLatencies[FunctionalUnitKind.FLOATINGSUM]; checkFPR[operation.getOperand(0)].register = operation.id; } break; - case Opcodes.MULTF: - if (checkFPR[operation.getOperand(0)].latency < functionalUnitLatencies[FunctionalUnitType.FLOATINGMULTIPLY]) { - checkFPR[operation.getOperand(0)].latency = functionalUnitLatencies[FunctionalUnitType.FLOATINGMULTIPLY]; + case OpcodeMnemonic.MULTF: + if (checkFPR[operation.getOperand(0)].latency < functionalUnitLatencies[FunctionalUnitKind.FLOATINGMULTIPLY]) { + checkFPR[operation.getOperand(0)].latency = functionalUnitLatencies[FunctionalUnitKind.FLOATINGMULTIPLY]; checkFPR[operation.getOperand(0)].register = operation.id; } break; - case Opcodes.LW: - if (checkGPR[operation.getOperand(0)].latency < functionalUnitLatencies[FunctionalUnitType.MEMORY]) { - checkGPR[operation.getOperand(0)].latency = functionalUnitLatencies[FunctionalUnitType.MEMORY]; + case OpcodeMnemonic.LW: + if (checkGPR[operation.getOperand(0)].latency < functionalUnitLatencies[FunctionalUnitKind.MEMORY]) { + checkGPR[operation.getOperand(0)].latency = functionalUnitLatencies[FunctionalUnitKind.MEMORY]; checkGPR[operation.getOperand(0)].register = operation.id; } break; - case Opcodes.LF: - if (checkFPR[operation.getOperand(0)].latency < functionalUnitLatencies[FunctionalUnitType.MEMORY]) { - checkFPR[operation.getOperand(0)].latency = functionalUnitLatencies[FunctionalUnitType.MEMORY]; + case OpcodeMnemonic.LF: + if (checkFPR[operation.getOperand(0)].latency < functionalUnitLatencies[FunctionalUnitKind.MEMORY]) { + checkFPR[operation.getOperand(0)].latency = functionalUnitLatencies[FunctionalUnitKind.MEMORY]; checkFPR[operation.getOperand(0)].register = operation.id; } break; - case Opcodes.SW: - case Opcodes.SF: - case Opcodes.BEQ: - case Opcodes.BNE: - case Opcodes.BGT: + case OpcodeMnemonic.SW: + case OpcodeMnemonic.SF: + case OpcodeMnemonic.BEQ: + case OpcodeMnemonic.BNE: + case OpcodeMnemonic.BGT: break; default: - throw new Error("Error at checkTargetOperation, unknown opcode: " + Opcodes[operation.opcode]); + throw new Error("Error at checkTargetOperation, unknown opcode: " + OpcodeMnemonic[operation.opcode]); } } public static checkSourceOperands(operation: VLIWOperation, checkGPR: Check[], checkFPR: Check[]): boolean { let result = true; switch (operation.opcode) { - case Opcodes.ADD: - case Opcodes.MULT: + case OpcodeMnemonic.ADD: + case OpcodeMnemonic.MULT: if (((checkGPR[operation.getOperand(1)].latency > 0) && (checkGPR[operation.getOperand(1)].register < operation.id)) || ((checkGPR[operation.getOperand(2)].latency > 0) && (checkGPR[operation.getOperand(2)].register < operation.id))) { result = false; } break; - case Opcodes.ADDI: + case OpcodeMnemonic.ADDI: if ((checkGPR[operation.getOperand(1)].latency > 0) && (checkGPR[operation.getOperand(1)].register < operation.id)) { result = false; } break; - case Opcodes.ADDF: - case Opcodes.MULTF: + case OpcodeMnemonic.ADDF: + case OpcodeMnemonic.MULTF: if (((checkFPR[operation.getOperand(1)].latency > 0) && (checkFPR[operation.getOperand(1)].register < operation.id)) || ((checkFPR[operation.getOperand(2)].latency > 0) && (checkFPR[operation.getOperand(2)].register < operation.id))) { result = false; } break; - case Opcodes.LW: - case Opcodes.LF: + case OpcodeMnemonic.LW: + case OpcodeMnemonic.LF: if ((checkGPR[operation.getOperand(2)].latency > 0) && (checkGPR[operation.getOperand(2)].register < operation.id)) { result = false; } break; - case Opcodes.SW: + case OpcodeMnemonic.SW: if (((checkGPR[operation.getOperand(0)].latency > 0) && (checkGPR[operation.getOperand(0)].register < operation.id)) || ((checkGPR[operation.getOperand(2)].latency > 0) && (checkGPR[operation.getOperand(2)].register < operation.id))) { result = false; } break; - case Opcodes.SF: + case OpcodeMnemonic.SF: if (((checkFPR[operation.getOperand(0)].latency > 0) && (checkFPR[operation.getOperand(0)].register < operation.id)) || ((checkGPR[operation.getOperand(2)].latency > 0) && (checkGPR[operation.getOperand(2)].register < operation.id))) { result = false; } break; - case Opcodes.BEQ: - case Opcodes.BNE: - case Opcodes.BGT: + case OpcodeMnemonic.BEQ: + case OpcodeMnemonic.BNE: + case OpcodeMnemonic.BGT: if (((checkGPR[operation.getOperand(0)].latency > 0) && (checkGPR[operation.getOperand(0)].register < operation.id)) || ((checkGPR[operation.getOperand(1)].latency > 0) && (checkGPR[operation.getOperand(1)].register < operation.id))) { result = false; } break; default: - throw new Error("Error at checkSourceOperands, unknown opcode: " + Opcodes[operation.opcode]); + throw new Error("Error at checkSourceOperands, unknown opcode: " + OpcodeMnemonic[operation.opcode]); } return result; } @@ -117,34 +117,34 @@ export class DependencyChecker { let result; switch (operation.opcode) { - case Opcodes.ADD: - case Opcodes.MULT: + case OpcodeMnemonic.ADD: + case OpcodeMnemonic.MULT: result = NaTGP[operation.getOperand(1)] || NaTGP[operation.getOperand(2)]; break; - case Opcodes.ADDI: + case OpcodeMnemonic.ADDI: result = NaTGP[operation.getOperand(1)]; break; - case Opcodes.ADDF: - case Opcodes.MULTF: + case OpcodeMnemonic.ADDF: + case OpcodeMnemonic.MULTF: result = NaTFP[operation.getOperand(1)] || NaTFP[operation.getOperand(2)]; break; - case Opcodes.SW: + case OpcodeMnemonic.SW: result = NaTGP[operation.getOperand(0)] || NaTGP[operation.getOperand(2)]; break; - case Opcodes.SF: + case OpcodeMnemonic.SF: result = NaTFP[operation.getOperand(0)] || NaTGP[operation.getOperand(2)]; break; - case Opcodes.LW: - case Opcodes.LF: + case OpcodeMnemonic.LW: + case OpcodeMnemonic.LF: result = NaTGP[operation.getOperand(2)]; break; - case Opcodes.BEQ: - case Opcodes.BNE: - case Opcodes.BGT: + case OpcodeMnemonic.BEQ: + case OpcodeMnemonic.BNE: + case OpcodeMnemonic.BGT: result = NaTGP[operation.getOperand(0)] || NaTGP[operation.getOperand(1)]; break; default: - throw new Error("Error at checkNat, unknown opcode: " + Opcodes[operation.opcode]); + throw new Error("Error at checkNat, unknown opcode: " + OpcodeMnemonic[operation.opcode]); } return result; } diff --git a/src/core/VLIW/VLIW.ts b/src/core/VLIW/VLIW.ts index 267dc9ab..86ce37cd 100644 --- a/src/core/VLIW/VLIW.ts +++ b/src/core/VLIW/VLIW.ts @@ -1,7 +1,7 @@ import { Machine } from '../Common/Machine'; -import { Opcodes } from '../Common/Opcodes'; +import { OpcodeMnemonic } from '../Common/Opcode'; import { VLIWCode } from './VLIWCode'; -import { FunctionalUnit, FunctionalUnitType, FUNCTIONALUNITTYPESQUANTITY } from '../Common/FunctionalUnit'; +import { FunctionalUnit, FunctionalUnitKind, FUNCTIONALUNITTYPESQUANTITY } from '../Common/FunctionalUnit'; import { DependencyChecker, Check } from './DependencyChecker'; import { VLIWError } from './VLIWError'; import { VLIWOperation } from './VLIWOperation'; @@ -110,13 +110,13 @@ export class VLIW extends Machine { let pending: boolean = false; this.status.cycle++; - if (!this.functionalUnit[FunctionalUnitType.JUMP][0].isEmpty()) { + if (!this.functionalUnit[FunctionalUnitKind.JUMP][0].isEmpty()) { pending = true; } - if (!this.functionalUnit[FunctionalUnitType.JUMP][0].isStalled()) { + if (!this.functionalUnit[FunctionalUnitKind.JUMP][0].isStalled()) { - let execution = this.functionalUnit[FunctionalUnitType.JUMP][0].executeReadyInstruction(); + let execution = this.functionalUnit[FunctionalUnitKind.JUMP][0].executeReadyInstruction(); let operation: any = (execution != null) ? execution.instruction : null; if (operation != null) { if (this._predR[operation.getPred()]) { @@ -125,7 +125,7 @@ export class VLIW extends Machine { } } - this.functionalUnit[FunctionalUnitType.JUMP][0].tic(); + this.functionalUnit[FunctionalUnitKind.JUMP][0].tic(); // check for stalled functional units let hasStalledFU = false; @@ -198,15 +198,15 @@ export class VLIW extends Machine { let operation = instruction.getOperation(i); this.functionalUnit[operation.getFunctionalUnitType()][operation.getFunctionalUnitIndex()].addInstruction(operation); - if (operation.opcode === Opcodes.LW) { + if (operation.opcode === OpcodeMnemonic.LW) { this._NaTGP[operation.getOperand(0)] = true; } - if (operation.opcode === Opcodes.LF) { + if (operation.opcode === OpcodeMnemonic.LF) { this._NaTFP[operation.getOperand(0)] = true; } - if (operation.getFunctionalUnitType() === FunctionalUnitType.JUMP) { + if (operation.getFunctionalUnitType() === FunctionalUnitKind.JUMP) { this._predR[operation.getPredTrue()] = false; this._predR[operation.getPredFalse()] = false; } @@ -235,28 +235,28 @@ export class VLIW extends Machine { private runOperation(operation: VLIWOperation, functionalUnit: FunctionalUnit) { switch (operation.opcode) { - case Opcodes.ADD: + case OpcodeMnemonic.ADD: this._gpr.setContent(operation.getOperand(0), this._gpr.content[operation.getOperand(1)] + this._gpr.content[operation.getOperand(2)], true); break; - case Opcodes.MULT: + case OpcodeMnemonic.MULT: this._gpr.setContent(operation.getOperand(0), this._gpr.content[operation.getOperand(1)] * this._gpr.content[operation.getOperand(2)], true); break; - case Opcodes.ADDI: + case OpcodeMnemonic.ADDI: this._gpr.setContent(operation.getOperand(0), this._gpr.content[operation.getOperand(1)] + operation.getOperand(2), true); break; - case Opcodes.ADDF: + case OpcodeMnemonic.ADDF: this._fpr.setContent(operation.getOperand(0), this._fpr.content[operation.getOperand(1)] + this._fpr.content[operation.getOperand(2)], true); break; - case Opcodes.MULTF: + case OpcodeMnemonic.MULTF: this._fpr.setContent(operation.getOperand(0), this._fpr.content[operation.getOperand(1)] * this._fpr.content[operation.getOperand(2)], true); break; - case Opcodes.SW: + case OpcodeMnemonic.SW: this._memory.setData(this._gpr.content[operation.getOperand(2)] + operation.getOperand(1), this._gpr.content[operation.getOperand(0)]); break; - case Opcodes.SF: + case OpcodeMnemonic.SF: this._memory.setData(this._gpr.content[operation.getOperand(2)] + operation.getOperand(1), this._fpr.content[operation.getOperand(0)]); break; - case Opcodes.LW: { + case OpcodeMnemonic.LW: { const datumInteger = this._memory.getData(this._gpr.content[operation.getOperand(2)] + operation.getOperand(1)); //hack: as we dont have a well made error handling, intercept the error and just throw it @@ -272,7 +272,7 @@ export class VLIW extends Machine { this._NaTGP[operation.getOperand(0)] = false; break; } - case Opcodes.LF: { + case OpcodeMnemonic.LF: { const datumFloat = this._memory.getData(this._gpr.content[operation.getOperand(2)] + operation.getOperand(1)); //hack: as we dont have a well made error handling, intercept the error and just throw it @@ -298,7 +298,7 @@ export class VLIW extends Machine { private runJump(operation: VLIWOperation): number { let newPC = this.pc; - if (operation.opcode === Opcodes.BEQ) { + if (operation.opcode === OpcodeMnemonic.BEQ) { if (this._gpr.content[operation.getOperand(0)] === this._gpr.content[operation.getOperand(1)]) { newPC = operation.getOperand(2); this._predR[operation.getPredTrue()] = true; @@ -307,7 +307,7 @@ export class VLIW extends Machine { this._predR[operation.getPredTrue()] = false; this._predR[operation.getPredFalse()] = true; } - } else if (operation.opcode === Opcodes.BNE) { + } else if (operation.opcode === OpcodeMnemonic.BNE) { if (this._gpr.content[operation.getOperand(0)] !== this._gpr.content[operation.getOperand(1)]) { newPC = operation.getOperand(2); this._predR[operation.getPredTrue()] = true; @@ -316,7 +316,7 @@ export class VLIW extends Machine { this._predR[operation.getPredTrue()] = false; this._predR[operation.getPredFalse()] = true; } - } else if (operation.opcode === Opcodes.BGT) { + } else if (operation.opcode === OpcodeMnemonic.BGT) { if (this._gpr.content[operation.getOperand(0)] > this._gpr.content[operation.getOperand(1)]) { newPC = operation.getOperand(2); this._predR[operation.getPredTrue()] = true; @@ -383,11 +383,11 @@ export class VLIW extends Machine { } let instruction = this._code.getLargeInstruction(row); for (let j = 0; j < instruction.getVLIWOperationsNumber(); j++) { - if (instruction.getOperation(j).getFunctionalUnitType() === FunctionalUnitType.JUMP) { + if (instruction.getOperation(j).getFunctionalUnitType() === FunctionalUnitKind.JUMP) { let check1: Check; let check2: Check; - check1.latency = this.functionalUnit[FunctionalUnitType.JUMP].length; - check2.latency = this.functionalUnit[FunctionalUnitType.JUMP].length; + check1.latency = this.functionalUnit[FunctionalUnitKind.JUMP].length; + check2.latency = this.functionalUnit[FunctionalUnitKind.JUMP].length; check1.register = instruction.getOperation(j).getPredTrue(); check2.register = instruction.getOperation(j).getPredFalse(); controlCheckList.push(check1); diff --git a/src/core/VLIW/VLIWOperation.ts b/src/core/VLIW/VLIWOperation.ts index 3616370e..cca796df 100644 --- a/src/core/VLIW/VLIWOperation.ts +++ b/src/core/VLIW/VLIWOperation.ts @@ -1,16 +1,16 @@ import { Instruction } from '../Common/Instruction'; -import { FunctionalUnitType } from '../Common/FunctionalUnit'; -import { Opcodes } from '../Common/Opcodes'; +import { FunctionalUnitKind } from '../Common/FunctionalUnit'; +import { OpcodeMnemonic } from '../Common/Opcode'; export class VLIWOperation extends Instruction { - private _functionalUnitType: FunctionalUnitType; + private _functionalUnitType: FunctionalUnitKind; private _functionalUnitIndex: number; private _predicate: number; private _predicateTrue: number; private _predicateFalse: number; - constructor(operation?: VLIWOperation, instruction?: Instruction, type?: FunctionalUnitType, functionalUnitIndex?: number) { + constructor(operation?: VLIWOperation, instruction?: Instruction, type?: FunctionalUnitKind, functionalUnitIndex?: number) { if (operation) { super(operation); this.buildFromVLIWOperation(operation); @@ -33,7 +33,7 @@ export class VLIWOperation extends Instruction { this._predicateFalse = operation._predicateFalse; } - buildFromInstruction(instruction: Instruction, functionalUnitType: FunctionalUnitType, functionalUnitIndex: number) { + buildFromInstruction(instruction: Instruction, functionalUnitType: FunctionalUnitKind, functionalUnitIndex: number) { this._functionalUnitType = functionalUnitType; this._functionalUnitIndex = functionalUnitIndex; this._predicate = 0; @@ -42,7 +42,7 @@ export class VLIWOperation extends Instruction { } // Getters - public getFunctionalUnitType(): FunctionalUnitType { + public getFunctionalUnitType(): FunctionalUnitKind { return this._functionalUnitType; } @@ -63,7 +63,7 @@ export class VLIWOperation extends Instruction { } // Setters - public setFunctionalUnitType(t: FunctionalUnitType) { + public setFunctionalUnitType(t: FunctionalUnitKind) { this._functionalUnitType = t; } diff --git a/src/core/VLIW/VLIWParser.ts b/src/core/VLIW/VLIWParser.ts index 26671509..87c0156c 100644 --- a/src/core/VLIW/VLIWParser.ts +++ b/src/core/VLIW/VLIWParser.ts @@ -16,7 +16,7 @@ import { } from "typescript-parsec"; import { FUNCTIONALUNITTYPESQUANTITY, - type FunctionalUnitType, + type FunctionalUnitKind, FunctionalUnitTypeNames, } from "../Common/FunctionalUnit"; import { LargeInstruction } from "./LargeInstructions"; @@ -40,7 +40,7 @@ const tokenizer = buildLexer([ const functionalUnitTypeParser = apply( tok(Tokens.Number), - (num: Token): FunctionalUnitType => { + (num: Token): FunctionalUnitKind => { const type = +num.text; if (type > FUNCTIONALUNITTYPESQUANTITY - 1) { throw new TokenError(num.pos, `Invalid functional unit type ${type}`); @@ -52,7 +52,7 @@ const functionalUnitTypeParser = apply( interface IndexParsed { index: number; isJump: boolean; - functionalUnitType: FunctionalUnitType; + functionalUnitType: FunctionalUnitKind; } export function Parse(input: string, code: Code): LargeInstruction[] { @@ -87,7 +87,7 @@ export function Parse(input: string, code: Code): LargeInstruction[] { const operationParser = apply( operationCombiner, - (componets: [FunctionalUnitType, Token[]]) => { + (componets: [FunctionalUnitKind, Token[]]) => { // Check if we received the right amount of operands if (componets[1].length < 2) { throw new TokenError( diff --git a/src/integration/superscalar-integration.ts b/src/integration/superscalar-integration.ts index 29c72580..a2d83ca2 100644 --- a/src/integration/superscalar-integration.ts +++ b/src/integration/superscalar-integration.ts @@ -25,7 +25,7 @@ import { import { displayBatchResults } from '../interface/actions/modals'; -import { FunctionalUnitType } from '../core/Common/FunctionalUnit'; +import { FunctionalUnitKind } from '../core/Common/FunctionalUnit'; import { pushHistory, takeHistory, resetHistory } from '../interface/actions/history'; import { MAX_HISTORY_SIZE } from '../interface/reducers/machine'; @@ -345,65 +345,65 @@ export class SuperscalarIntegration extends MachineIntegration { saveSuperConfig = (superConfig) => { this.superscalar.changeFunctionalUnitNumber( - FunctionalUnitType.INTEGERSUM, + FunctionalUnitKind.INTEGERSUM, +superConfig.integerSumQuantity, ); this.superscalar.changeFunctionalUnitLatency( - FunctionalUnitType.INTEGERSUM, + FunctionalUnitKind.INTEGERSUM, +superConfig.integerSumLatency, ); this.superscalar.changeFunctionalUnitNumber( - FunctionalUnitType.INTEGERMULTIPLY, + FunctionalUnitKind.INTEGERMULTIPLY, +superConfig.integerMultQuantity, ); this.superscalar.changeFunctionalUnitLatency( - FunctionalUnitType.INTEGERMULTIPLY, + FunctionalUnitKind.INTEGERMULTIPLY, +superConfig.integerMultLatency, ); this.superscalar.changeFunctionalUnitNumber( - FunctionalUnitType.FLOATINGSUM, + FunctionalUnitKind.FLOATINGSUM, +superConfig.floatingSumQuantity, ); this.superscalar.changeFunctionalUnitLatency( - FunctionalUnitType.FLOATINGSUM, + FunctionalUnitKind.FLOATINGSUM, +superConfig.floatingSumLatency, ); this.superscalar.changeFunctionalUnitNumber( - FunctionalUnitType.FLOATINGSUM, + FunctionalUnitKind.FLOATINGSUM, +superConfig.floatingSumQuantity, ); this.superscalar.changeFunctionalUnitLatency( - FunctionalUnitType.FLOATINGSUM, + FunctionalUnitKind.FLOATINGSUM, +superConfig.floatingSumLatency, ); this.superscalar.changeFunctionalUnitNumber( - FunctionalUnitType.FLOATINGMULTIPLY, + FunctionalUnitKind.FLOATINGMULTIPLY, +superConfig.floatingMultQuantity, ); this.superscalar.changeFunctionalUnitLatency( - FunctionalUnitType.FLOATINGMULTIPLY, + FunctionalUnitKind.FLOATINGMULTIPLY, +superConfig.floatingMultLatency, ); this.superscalar.changeFunctionalUnitNumber( - FunctionalUnitType.JUMP, + FunctionalUnitKind.JUMP, +superConfig.jumpQuantity, ); this.superscalar.changeFunctionalUnitLatency( - FunctionalUnitType.JUMP, + FunctionalUnitKind.JUMP, +superConfig.jumpLatency, ); this.superscalar.changeFunctionalUnitNumber( - FunctionalUnitType.MEMORY, + FunctionalUnitKind.MEMORY, +superConfig.memoryQuantity, ); this.superscalar.changeFunctionalUnitLatency( - FunctionalUnitType.MEMORY, + FunctionalUnitKind.MEMORY, +superConfig.memoryLatency, ); diff --git a/src/integration/vliw-integration.ts b/src/integration/vliw-integration.ts index 8f62070a..dcbaa73e 100644 --- a/src/integration/vliw-integration.ts +++ b/src/integration/vliw-integration.ts @@ -30,7 +30,7 @@ import { displayBatchResults } from '../interface/actions/modals'; import { Stats } from '../stats/stats'; import { StatsAgregator } from '../stats/aggregator'; -import { FunctionalUnitType } from '@/core/Common/FunctionalUnit'; +import { FunctionalUnitKind } from '@/core/Common/FunctionalUnit'; export class VLIWIntegration extends MachineIntegration { // Global objects for binding React to the View @@ -350,65 +350,65 @@ export class VLIWIntegration extends MachineIntegration { saveVliwConfig = (vliwConfig) => { this.vliw.changeFunctionalUnitNumber( - FunctionalUnitType.INTEGERSUM, + FunctionalUnitKind.INTEGERSUM, +vliwConfig.integerSumQuantity, ); this.vliw.changeFunctionalUnitLatency( - FunctionalUnitType.INTEGERSUM, + FunctionalUnitKind.INTEGERSUM, +vliwConfig.integerSumLatency, ); this.vliw.changeFunctionalUnitNumber( - FunctionalUnitType.INTEGERMULTIPLY, + FunctionalUnitKind.INTEGERMULTIPLY, +vliwConfig.integerMultQuantity, ); this.vliw.changeFunctionalUnitLatency( - FunctionalUnitType.INTEGERMULTIPLY, + FunctionalUnitKind.INTEGERMULTIPLY, +vliwConfig.integerMultLatency, ); this.vliw.changeFunctionalUnitNumber( - FunctionalUnitType.FLOATINGSUM, + FunctionalUnitKind.FLOATINGSUM, +vliwConfig.floatingSumQuantity, ); this.vliw.changeFunctionalUnitLatency( - FunctionalUnitType.FLOATINGSUM, + FunctionalUnitKind.FLOATINGSUM, +vliwConfig.floatingSumLatency, ); this.vliw.changeFunctionalUnitNumber( - FunctionalUnitType.FLOATINGSUM, + FunctionalUnitKind.FLOATINGSUM, +vliwConfig.floatingSumQuantity, ); this.vliw.changeFunctionalUnitLatency( - FunctionalUnitType.FLOATINGSUM, + FunctionalUnitKind.FLOATINGSUM, +vliwConfig.floatingSumLatency, ); this.vliw.changeFunctionalUnitNumber( - FunctionalUnitType.FLOATINGMULTIPLY, + FunctionalUnitKind.FLOATINGMULTIPLY, +vliwConfig.floatingMultQuantity, ); this.vliw.changeFunctionalUnitLatency( - FunctionalUnitType.FLOATINGMULTIPLY, + FunctionalUnitKind.FLOATINGMULTIPLY, +vliwConfig.floatingMultLatency, ); this.vliw.changeFunctionalUnitNumber( - FunctionalUnitType.JUMP, + FunctionalUnitKind.JUMP, +vliwConfig.jumpQuantity, ); this.vliw.changeFunctionalUnitLatency( - FunctionalUnitType.JUMP, + FunctionalUnitKind.JUMP, +vliwConfig.jumpLatency, ); this.vliw.changeFunctionalUnitNumber( - FunctionalUnitType.MEMORY, + FunctionalUnitKind.MEMORY, +vliwConfig.memoryQuantity, ); this.vliw.changeFunctionalUnitLatency( - FunctionalUnitType.MEMORY, + FunctionalUnitKind.MEMORY, +vliwConfig.memoryLatency, ); diff --git a/src/interface/actions/table-actions.ts b/src/interface/actions/table-actions.ts index 13f7cfa8..560a4baa 100644 --- a/src/interface/actions/table-actions.ts +++ b/src/interface/actions/table-actions.ts @@ -1,4 +1,4 @@ -import { FunctionalUnit, FunctionalUnitType } from '../../core/Common/FunctionalUnit'; +import { FunctionalUnit, FunctionalUnitKind } from '../../core/Common/FunctionalUnit'; export const HEADER_TABLE_CYCLE = 'HEADER_TABLE_CYCLE'; export const TABLE_CYCLE = 'TABLE_CYCLE'; @@ -44,33 +44,33 @@ function mapVLIWTableData(data, functionalUnitNumbers: number[]): any { for (let i = 0; i < data.getVLIWOperationsNumber(); i++) { // numero de instrucciones cortas en la instrucción larga for (let j = 0; j < cols.length; j++) { - if ((data.getOperation(i).getFunctionalUnitType() === FunctionalUnitType.INTEGERSUM) + if ((data.getOperation(i).getFunctionalUnitType() === FunctionalUnitKind.INTEGERSUM) && (data.getOperation(i).getFunctionalUnitIndex() === j)) { cols[j] = data.getOperation(i).id; - } else if ((data.getOperation(i).getFunctionalUnitType() === FunctionalUnitType.INTEGERMULTIPLY) + } else if ((data.getOperation(i).getFunctionalUnitType() === FunctionalUnitKind.INTEGERMULTIPLY) && ((data.getOperation(i).getFunctionalUnitIndex() + functionalUnitNumbers[0]) === j)) { cols[j] = data.getOperation(i).id; - } else if ((data.getOperation(i).getFunctionalUnitType() === FunctionalUnitType.FLOATINGSUM) + } else if ((data.getOperation(i).getFunctionalUnitType() === FunctionalUnitKind.FLOATINGSUM) && ((data.getOperation(i).getFunctionalUnitIndex() + functionalUnitNumbers[0] + functionalUnitNumbers[1]) === j)) { cols[j] = data.getOperation(i).id; - } else if ((data.getOperation(i).getFunctionalUnitType() === FunctionalUnitType.FLOATINGMULTIPLY) + } else if ((data.getOperation(i).getFunctionalUnitType() === FunctionalUnitKind.FLOATINGMULTIPLY) && ((data.getOperation(i).getFunctionalUnitIndex() + functionalUnitNumbers[0] + functionalUnitNumbers[1] + functionalUnitNumbers[2]) === j)) { cols[j] = data.getOperation(i).id; - } else if ((data.getOperation(i).getFunctionalUnitType() === FunctionalUnitType.MEMORY) + } else if ((data.getOperation(i).getFunctionalUnitType() === FunctionalUnitKind.MEMORY) && ((data.getOperation(i).getFunctionalUnitIndex() + functionalUnitNumbers[0] + functionalUnitNumbers[1] + functionalUnitNumbers[2] + functionalUnitNumbers[3]) === j)) { cols[j] = data.getOperation(i).id; - } else if ((data.getOperation(i).getFunctionalUnitType() === FunctionalUnitType.JUMP) + } else if ((data.getOperation(i).getFunctionalUnitType() === FunctionalUnitKind.JUMP) && ((data.getOperation(i).getFunctionalUnitIndex() + functionalUnitNumbers[0] + functionalUnitNumbers[1] + functionalUnitNumbers[2] + functionalUnitNumbers[3] + functionalUnitNumbers[4]) === j)) { diff --git a/src/interface/components/Superscalar/CodeComponent.tsx b/src/interface/components/Superscalar/CodeComponent.tsx index 84de5c2c..fb11a06a 100644 --- a/src/interface/components/Superscalar/CodeComponent.tsx +++ b/src/interface/components/Superscalar/CodeComponent.tsx @@ -1,5 +1,5 @@ import * as React from 'react'; -import { OpcodesNames } from '../../../core/Common/Opcodes'; +import { OpcodesNames } from '../../../core/Common/Opcode'; import { Instruction } from '../../../core/Common/Instruction'; diff --git a/src/interface/components/VLIW/InstructionComponent.tsx b/src/interface/components/VLIW/InstructionComponent.tsx index bfd5fd60..bfc0bb68 100644 --- a/src/interface/components/VLIW/InstructionComponent.tsx +++ b/src/interface/components/VLIW/InstructionComponent.tsx @@ -2,7 +2,7 @@ import * as React from 'react'; import { useDrag } from 'react-dnd'; -import { OpcodesNames } from '../../../core/Common/Opcodes'; +import { OpcodesNames } from '../../../core/Common/Opcode'; import { Instruction } from '../../../core/Common/Instruction'; diff --git a/src/test/functional/Superscalar/iteratelist.spec.ts b/src/test/functional/Superscalar/iteratelist.spec.ts index f40f5ab5..f60fbbf6 100644 --- a/src/test/functional/Superscalar/iteratelist.spec.ts +++ b/src/test/functional/Superscalar/iteratelist.spec.ts @@ -2,7 +2,7 @@ import { expect, beforeEach, test } from 'vitest' import { Code } from '../../../core/Common/Code'; import { Superscalar } from '../../../core/Superscalar/Superscalar'; import { SuperscalarStatus } from '../../../core/Superscalar/SuperscalarEnums'; -import { FunctionalUnitType } from '../../../core/Common/FunctionalUnit'; +import { FunctionalUnitKind } from '../../../core/Common/FunctionalUnit'; import { codeInput, memContent } from "../code/recorrelista"; @@ -38,9 +38,9 @@ test('recorrelista.pla is executed properly', t => { // Check that instructions are being executed in the correct Functional Units // 13 -> FLOATINGMULTIPLY, 16 -> MEMORY and 12 -> JUMP - expect(context.machine.functionalUnit[FunctionalUnitType.FLOATINGMULTIPLY][0].getVisualData().filter(e => e.id === 13).length).toBeGreaterThan(0); // Instruction 13 is not at FLOATINGMULTIPLY Functional unit at cycle 40'); - expect(context.machine.functionalUnit[FunctionalUnitType.MEMORY][0].getVisualData().filter(e => e.id === 16).length).toBeGreaterThan(0); // Instruction 16 is not at MEMORY Functional unit at cycle 40'); - expect(context.machine.functionalUnit[FunctionalUnitType.JUMP][0].getVisualData().filter(e => e.id === 12).length).toBeGreaterThan(0); // Instruction 12 is not at JUMP Functional unit at cycle 40'); + expect(context.machine.functionalUnit[FunctionalUnitKind.FLOATINGMULTIPLY][0].getVisualData().filter(e => e.id === 13).length).toBeGreaterThan(0); // Instruction 13 is not at FLOATINGMULTIPLY Functional unit at cycle 40'); + expect(context.machine.functionalUnit[FunctionalUnitKind.MEMORY][0].getVisualData().filter(e => e.id === 16).length).toBeGreaterThan(0); // Instruction 16 is not at MEMORY Functional unit at cycle 40'); + expect(context.machine.functionalUnit[FunctionalUnitKind.JUMP][0].getVisualData().filter(e => e.id === 12).length).toBeGreaterThan(0); // Instruction 12 is not at JUMP Functional unit at cycle 40'); } if (context.machine.status.cycle === 60 || context.machine.status.cycle === 70) { // at cycle 70 the jump is still looping @@ -70,4 +70,4 @@ test('recorrelista.pla is executed properly', t => { // Check the result expect(Array.from(context.machine.memory)[9]).toBe(12); -}) \ No newline at end of file +})