Team Leader: Srishti, Team Member: Krishna,: Ss878@msstate - Edu Kvt11@msstate - Edu

Final Report for Team K
1. Team Members
Team Leader: Srishti, ss878@msstate.edu
Team member: Krishna, kvt11@msstate.edu
2. Meetings (Oct 30 – December 1)
Name # of meetings # of attendance Contribution hours

Srishti 11 11 3-6hrs per meeting
Krishna 11 11 3-6hrs per meeting
3. Datapath with Control unit
a) Datapath without the new instructions:

b) Datapath with the new instructions:
4. Finite State Machine
5. ALU Control
Operation ALUOp
Add 0000
Sub 0001
Addi 0010
LW 0011
SW 0100
And 0101
Or 0110
Ori 1001
SLL 1010
BEQ 1100
BNE 1101
SLT 1110
J 1111
6. Initial contents of the memory and register file at clock cycle 0
Memory (data + instructions):
0x10 0x0101
0x12 0x0110
0x14 0x0011
0x16 0x00F0
0x18 0xFFFF
Register File (data):
Register 0 ($v0) 0
Register 1 ($v1) 0
Register 2 ($v2) 0
Register 3 ($v3) 0
Register 4 ($a0) 0
Register 5 ($a1) 0
Register 6 ($t0) 0
Register 7 ($t1) 0
8. Output data from the simulation results:
After the program is compiled and run the following output appears:
MEMORY
Memory[1000]: 0010011100000100
Memory[1002]: 1010000000000100
Memory[1004]: 0010011100010001
Memory[1006]: 0010011100100111
Memory[1008]: 1010001000100001
Memory[1010]: 0010001000100001
Memory[1012]: 0010001000110000
Memory[1014]: 1010001100110100
Memory[1016]: 0010011101000000
Memory[1018]: 0010011101010100
Memory[1020]: 1010010101010010
Memory[1022]: 0010011101100101
Memory[1024]: 0010011111110001
Memory[1026]: 1110011101101000
Memory[1028]: 1100111110000010
Memory[1030]: 1111010001010110
Memory[1032]: 0001011011110110
Memory[1034]: 0011010101000000
Memory[1036]: 0010010101010010
Memory[1038]: 0010011110010111
Memory[1040]: 1010100110010001
Memory[1042]: 0010100110010001
Memory[1044]: 1010100110010011
Memory[1046]: 0010100110010111
Memory[1048]: 1010100110010001
Memory[1050]: 0010100110010001
Memory[1052]: 1110100101001010
Memory[1054]:
Memory[1056]:
REGISTERS
Register[0]: 0
Register[1]: 0
Register[2]: 0
Register[3]: 0
Register[4]: 0
Register[5]: 0
Register[6]: 0
Register[7]: 0
1000 - Decode Opcode: 0010

ALUSrcB binaryDecimal: 0100
*************WRITEBACK********WriteData: 4; WriteReg: 0; RegDst: 0; Temp: 4
RegArray[0]: 4
RegArray[0]: 64
RegArray[1]: 1
RegArray[2]: 7
RegArray[2]: 14
RegArray[2]: 15
RegArray[3]: 15
RegArray[3]: 240
RegArray[4]: 0
RegArray[5]: 4
RegArray[5]: 16
RegArray[6]: 5
RegArray[15]: 1
RegArray[6]: 4
LW/SW: MuxA = 16 MuxB = 0 ALUResult = 16 Instruction: 0011010101000000
ALUResult: 16
LOAD WORD! regArray[4] = 0000000100000000
RegArray[5]: 18
RegArray[9]: 7
RegArray[9]: 14
RegArray[9]: 15
RegArray[9]: 120
RegArray[9]: 127
RegArray[9]: 254
RegArray[9]: 255
RegArray[0]: 32
RegArray[11]: 0
RegArray[12]: 257
RegArray[1]: 257
RegArray[13]: 7
RegArray[13]: 14
RegArray[13]: 15
RegArray[13]: 120
RegArray[13]: 127
RegArray[13]: 254
RegArray[13]: 255
ALOHA
z = 13; regArray[13] = 255
ALOHA
c1: 255; c2: 65280; c3: 65535
Memory[16] = 65535; y = 16
jaddr: 010000000010; intJump: 1026
RegArray[6]: 3
ALUResult: 18
RegArray[5]: 20
RegArray[9]: 7
RegArray[9]: 14
RegArray[9]: 15
RegArray[9]: 120
RegArray[9]: 127
RegArray[9]: 254
RegArray[9]: 255
RegArray[0]: 16
RegArray[11]: 256
RegArray[12]: 273
RegArray[1]: 17
RegArray[13]: 7
RegArray[13]: 14
RegArray[13]: 15
RegArray[13]: 120
RegArray[13]: 127
RegArray[13]: 254
RegArray[13]: 255
ALOHA
z = 13; regArray[13] = 255
ALOHA
c1: 255; c2: 65280; c3: 65535
Memory[18] = 65535; y = 18
jaddr: 010000000010; intJump: 1026
RegArray[6]: 2
ALUResult: 20
RegArray[5]: 22
RegArray[9]: 7
RegArray[9]: 14
RegArray[9]: 15
RegArray[9]: 120
RegArray[9]: 127
RegArray[9]: 254
RegArray[9]: 255
RegArray[0]: 8
RegArray[11]: 17
RegArray[12]: 273
RegArray[1]: 256
RegArray[13]: 7
RegArray[13]: 14
RegArray[13]: 15
RegArray[13]: 120
RegArray[13]: 127
RegArray[13]: 254
RegArray[13]: 255
ALOHA
z = 13; regArray[13] = 255
ALOHA
c1: 255; c2: 65280; c3: 65535
Memory[20] = 65535; y = 20
jaddr: 010000000010; intJump: 1026
RegArray[6]: 1
ALUResult: 22
RegArray[5]: 24
RegArray[9]: 7
RegArray[9]: 14
RegArray[9]: 15
RegArray[9]: 120
RegArray[9]: 127
RegArray[9]: 254
RegArray[9]: 255
jaddr: 010000111110; intJump: 1086
RegArray[2]: 30
RegArray[3]: 240
RegArray[14]: 7
RegArray[14]: 14
RegArray[14]: 15
RegArray[14]: 120
RegArray[14]: 127
RegArray[14]: 254
RegArray[14]: 255
ALOHA
z = 14; regArray[14] = 255
ALOHA
c1: 255; c2: 0; c3: 255
Memory[22] = 255; y = 22
jaddr: 010000000010; intJump: 1026
RegArray[6]: 0
ALUResult: 24
RegArray[5]: 26
RegArray[9]: 7
RegArray[9]: 14
RegArray[9]: 15
RegArray[9]: 120
RegArray[9]: 127
RegArray[9]: 254
RegArray[9]: 255
jaddr: 010000111110; intJump: 1086
RegArray[2]: 60
RegArray[3]: 240
RegArray[14]: 7
RegArray[14]: 14
RegArray[14]: 15
RegArray[14]: 120
RegArray[14]: 127
RegArray[14]: 254
RegArray[14]: 255
ALOHA
z = 14; regArray[14] = 255
ALOHA
c1: 255; c2: 0; c3: 255
Memory[24] = 255; y = 24
jaddr: 010000000010; intJump: 1026
jaddr: 010001010110; intJump: 1110
REGISTERS
Register[0]: 8
Register[1]: 256
Register[2]: 60
Register[3]: 240
Register[4]: 255
Register[5]: 26
Register[6]: 0
Register[7]: 0
MEMORY
Memory[16]: 65535
Memory[18]: 65535
Memory[20]: 65535
Memory[22]: 255
Memory[24]: 255
9. Discussion
The program, written using visual studio 2005 compiles successfully.

The executable generated runs successfully for the instructions related to the pseudo code provided.
The issue of keeping track of the clock cycles has not been dealt with. Thus the program runs and gives the
correct outputs but it does not mention the clock cycle of execution.
There has been confusion in the total number of registers. The program deals with using 8 registers; however,
implementation with 16 registers might have been better.
10. Final Version of Simulator Code (Attached)
#include "stdafx.h"
#include <iostream>
#include <fstream>
#include <stdlib.h>
#include <iomanip>
#include <string>
#include <stdio.h>
#include <cmath>
#include <sstream>
using namespace std;
//Defining functions
void Initialize( );
void funcALU( int ALUa, int ALUb );
void Fetch( );
void Decode( );
void Execute( int state );
void MemAccess( int ALUResult );
void WriteBack( );
int binaryDecimal ( string );
//Variables
int y,
z,
c1,
c2,
c3;
string Memory[ 1200 ];
int regArray[ 16 ];
int ALUread = 0;
string memstring;
int programCounter = 0;
string instruction;
string opCode;
string rs,
rt,
rd,
imm,
jaddr;
int state,
nextState,
ALUa,
ALUb,
ALUResult;
int memData,
WriteData,
WriteReg,
intJump = 0;
//Control Signals
int PCWriteCond,
PCWrite,
IorD,
MemRead,
MemWrite,
MemtoReg,
IRWrite,
PCSource,
ALUOp,
ALUSrcB,
ALUSrcA,
RegWrite,
RegDst;
int main( )
{ //Initialize Memory contents
Memory[ 16 ] = "0000000100000001"; // 0101hex
Memory[ 18 ] = "0000000100010000"; // 0110hex
Memory[ 20 ] = "0000000000010001"; // 0011hex
Memory[ 22 ] = "0000000011110000"; // 00F0hex
Memory[ 24 ] = "0000000011111111"; // 00FFhex
//Opening and storing the input file into memory

ifstream inFile;
inFile.open( "machinecode.txt" );
int tempInt;
for( int i = 0; i <= 108; i = i + 2 ) // < >
{
getline( inFile, memstring );
Memory[ 1000 + i ] = memstring;

}
//Closing the input file

inFile.close( );
//Printing the initial memory contents to the screen

cout << "MEMORY" << endl;
for( int k = 1000; k <= 1056; k = k + 2 ) // < >
cout << "Memory[" << k << "]: " << Memory[ k ] << endl;
//Printing the initial register contents to the screen

cout << endl << "REGISTERS" << endl;
for( int k = 0; k <= 15; k++ ) // < >
cout << "Register[" << k << "]: " << regArray[ k ] << endl;
programCounter = 1000;
while( programCounter < 1110 )
{
cout << programCounter << " - ";
Initialize( );
Fetch( );
Decode( );
//funcALU(ALUa, ALUb);
//Printing the final register contents to the screen

cout << endl << "REGISTERS" << endl;
for( int k = 0; k <= 15; k++ ) // < >
cout << "Register[" << k << "]: " << regArray[ k ] << endl;
//Printing the initial memory contents to the screen

cout << "MEMORY" << endl;
for( int k = 16; k <= 24; k = k + 2 ) // < >
cout << "Memory[" << k << "]: " << Memory[ k ] << endl;
//funcALU(ALUa,ALUb);
system( "pause" );
return 0;
}
int binaryDecimal( string memstring )

{
int temp = 0;
int adder = 0;
int multiplier = 1;
int value = 0;
for( int i = memstring.size( ) - 1; i >= 0; i-- ) // < >

{
if( temp > 0 )
{
multiplier = 1;
for( int j = 0; j < temp; j++ ) // <>
{
multiplier = multiplier * 2;
}
}
if( memstring[ i ] == '1' )

{
adder = multiplier;
}
else
adder = 0;
value = value + adder;

temp++;
}
return value;
}
void Initialize( )
{
PCWriteCond = 0;
PCWrite = 0;
IorD = 0;
MemRead = 0;
MemWrite = 0;
MemtoReg = 0;
IRWrite = 0;
PCSource = 0;
ALUOp = 0;
ALUSrcB = 0;
ALUSrcA = 0;
RegWrite = 0;
RegDst = 0;
void Fetch( )
{
MemRead = 1;
ALUSrcA = 0;
IorD = 0;
IRWrite = 1;
ALUSrcB = 1;
ALUOp = 0;
PCWrite = 1;
PCSource = 0;
instruction = Memory[ programCounter ];

programCounter = programCounter + 2;
void Decode( )
{
ALUSrcA = 0;
ALUSrcB = 3;
ALUOp = 0;
//Clearing the registers

rs = "";
rt = "";
rd = "";
imm = "";
jaddr = "";
//Opcode is first 4 bits of the instruction

opCode = instruction.substr( 0, 4 );
cout << "Decode Opcode: " << opCode << endl;
//R-type instructions
if( opCode == "0000" || opCode == "0001"
|| opCode == "0101" || opCode == "0110"
|| opCode == "1000" || opCode == "1110" )
{
rs = instruction.substr( 4, 4 );
rt = instruction.substr( 8, 4 );
rd = instruction.substr( 12, 4 );
ALUa = binaryDecimal( rs );
ALUb = binaryDecimal( rt );
//I-type instructions
if( opCode == "0010" || opCode == "0011"
|| opCode == "0100" || opCode == "0111"
|| opCode == "1001" || opCode == "1010"
|| opCode == "1011" || opCode == "1100"
|| opCode == "1101" || opCode == "1111"
)
{
rs = instruction.substr( 4, 4 );
rt = instruction.substr( 8, 4 );
imm = instruction.substr( 12, 4 );
ALUa = binaryDecimal( rs );
ALUb = binaryDecimal( rt );
//J-type instruction
if( opCode == "1111" )
{
jaddr = instruction.substr( 4, 12 );
}
if( opCode == "0000" ) // add

Execute( 2 );
if( opCode == "0001" ) // subtract
Execute( 3 );
if( opCode == "0010" ) // add immediate

Execute( 4 );
if( opCode == "0011" ) // load word

Execute( 5 );
if( opCode == "0100" ) // store word

Execute( 6 );
if( opCode == "0101" ) // and

Execute( 7 );
if( opCode == "0110" ) // or

Execute( 8 );
if( opCode == "0111" ) // lw immediate

Execute( 9 );
if( opCode == "1000" ) // mult and accumulate

Execute( 10 );
if( opCode == "1001" ) // or immediate

Execute( 11 );
if( opCode == "1010" ) // shift left logical

Execute( 12 );
if( opCode == "1011" ) // shift right logical

Execute( 13 );
if( opCode == "1100" ) // branch on equal

Execute( 14 );
if( opCode == "1101" ) // branch on not equal

Execute( 15 );
if( opCode == "1110" ) // set on less than

Execute( 16 );
if( opCode == "1111" ) // jump

Execute( 17 );
nextState = 0;
}
void Execute( int state )

{
if( state == 2 ) // add
{
ALUSrcA = 1;
ALUSrcB = 0;
ALUOp = 0;
RegDst = 1;
RegWrite = 1;
MemtoReg = 0;
funcALU( ALUa, ALUb );
WriteBack( );
}
if( state == 3 ) // subtract

{
ALUSrcA = 1;
ALUSrcB = 0;
ALUOp = 1;
RegDst = 1;
RegWrite = 1;
MemtoReg = 0;
WriteBack( );
}
if( state == 4 ) // addi

{
ALUSrcA = 1;
ALUSrcB = 2;
ALUOp = 0;
RegDst = 0;
RegWrite = 1;
MemtoReg = 0;
WriteBack( );
}
if( state == 5 ) // lw
{
ALUSrcA = 1;
ALUSrcB = 2;
ALUOp = 2;
MemRead = 1;
MemWrite = 0;
IorD = 1;
RegDst = 0;
RegWrite = 1;
MemtoReg = 1;
MemAccess( ALUResult );
}
if( state == 6 ) // sw
{
ALUa = binaryDecimal( instruction.substr( 4, 4 ) );
ALUb = binaryDecimal( instruction.substr( 12, 4 ) );
ALUSrcA = 1;
ALUSrcB = 2;
ALUOp = 2;
MemWrite = 1;
MemRead = 0;
IorD = 1;
MemAccess( ALUResult );
}
if( state == 7 ) // and

{
ALUSrcA = 1;
ALUSrcB = 0;
ALUOp = 3;
RegDst = 1;
RegWrite = 1;
MemtoReg = 0;
WriteBack( );
}
if( state == 8 ) // or
{
ALUSrcA = 1;
ALUSrcB = 0;
ALUOp = 4;
RegDst = 1;
RegWrite = 1;
MemtoReg = 0;
WriteBack( );
}
if( state == 9 ) // lwi

{
ALUSrcA = 1;
ALUSrcB = 0;
ALUOp = 5;
RegDst = 0;
RegWrite = 1;
MemtoReg = 1;
WriteBack( );
}
if( state == 10 ) // mac

{
ALUSrcA = 1;
ALUSrcB = 2;
ALUOp = 8;
RegDst = 1;
RegWrite = 1;
MemtoReg = 0;
WriteBack( );
}
if( state == 11 ) // ori

{
ALUSrcA = 1;
ALUSrcB = 2;
ALUOp = 7;
RegDst = 0;
RegWrite = 1;
MemtoReg = 0;
WriteBack( );
}
if( state == 12 ) // shift left logical

{
ALUSrcA = 1;
ALUSrcB = 2;
ALUOp = 8;
RegDst = 0;
RegWrite = 1;
MemtoReg = 0;
WriteBack( );
if( state == 13 ) // shift right logical

{
ALUSrcA = 1;
ALUSrcB = 2;
ALUOp = 9;
RegDst = 0;
RegWrite = 1;
MemtoReg = 0;
WriteBack( );
}
if( state == 14 ) // branch on equal

{
ALUSrcA = 1;
ALUSrcB = 0;
ALUOp = 12;
PCWriteCond = 1;
PCSource = 1;
}
if( state == 15 ) // branch on not equal

{
ALUSrcA = 1;
ALUSrcB = 0;
ALUOp = 13;
PCWriteCond = 1;
PCSource = 1;
}
if( state == 16 ) // set on less than

{
ALUSrcA = 1;
ALUSrcB = 0;
ALUOp = 14;
RegDst = 1;
RegWrite = 1;
MemtoReg = 0;
}
if( state == 17 ) // jump

{
PCWrite = 1;
PCSource = 2;
jaddr = instruction.substr( 4, 12 );
intJump = binaryDecimal( jaddr );
cout << "jaddr: " << jaddr << "; intJump: " << intJump << endl;
programCounter = intJump;
}
}
void funcALU( int ALUa, int ALUb )

{
int muxA = 0;
int muxB = 0;
int temp1 = 0;
int temp2 = 0;
if( ALUSrcA == 0 )
muxA = PCSource;
if( ALUSrcA == 1 )
muxA = regArray[ ALUa ];
if( ALUSrcB == 0 )
muxB = regArray[ ALUb ];
if( ALUSrcB == 1 )
muxB = 2;
if( ALUSrcB == 2 )
{
muxB = binaryDecimal( imm );
cout << "ALUSrcB binaryDecimal: " << imm << endl;
}
if( ALUSrcB == 3 )
muxB = ( binaryDecimal( imm ) * 2 );
if( ALUOp == 0 ) // add, addi
ALUResult = muxA + muxB;
if( ALUOp == 1 ) // sub

ALUResult = muxA - muxB;
if( ALUOp == 2 )
{ // lw, sw
if( MemRead == 1 )
{
muxB = ( binaryDecimal( imm ) * 2 );
cout << "LW/SW: MuxA = " << muxA << " MuxB = " << muxB << " ALUResult = "
<< ALUResult << " Instruction: " << instruction << endl;
}
}
if( ALUOp == 3 || ALUOp == 6 ) // and

ALUResult = muxA & muxB;
if( ALUOp == 4 || ALUOp == 7 ) // or, ori

ALUResult = muxA | muxB;
if( ALUOp == 5 )
{ // lwi
if( MemRead == 1 )
{
muxB = ( binaryDecimal( imm ) + 4 );
cout << "LW/SW: MuxA = " << muxA << " MuxB = " << muxB << " ALUResult = "
<< ALUResult << " Instruction: " << instruction << endl;
}
}
if( ALUOp == 8 ) // sll

ALUResult = muxA << muxB;
if( ALUOp == 9 ) // srl

ALUResult = muxA >> muxB;
if( ALUOp == 12 ) // beq

{
if( muxA == muxB )

programCounter = programCounter + binaryDecimal( imm );
}
if( ALUOp == 13 ) // bne

{
if( muxA != muxB )
programCounter = programCounter + binaryDecimal( imm );
}
if( ALUOp == 14 ) // slt

{
int rdi = binaryDecimal( rd );
if( ( muxA - muxB ) < 0 )

{
regArray[ rdi ] = 1;
}
else
{
regArray[ rdi ] = 0;
}
}
while( ALUOp == 15 ) // mac
{
temp1 = muxA * muxB;
temp2 = temp2 + temp1;
ALUResult = temp2;
}
}
void MemAccess( int ALU_B )

{
char temp[ 16 ];
int z;
//load word
if( ( MemRead == 1 ) && ( IorD == 1 ) )
{
z = binaryDecimal( instruction.substr( 8, 4 ) );
cout << "ALUResult: " << ALUResult << endl;
cout << "LOAD WORD! regArray[" << z << "] = " << Memory[ ALUResult ] << endl;
regArray[ z ] = binaryDecimal( Memory[ ALUResult ] );
memData = atoi( Memory[ ALUResult ].c_str( ) );
}
//store word
if( ( MemWrite == 1 ) && ( IorD == 1 ) )
{
cout << "skm" << endl;
if( ALUread == 0 )
{
c1 = regArray[ z ];
cout << "z = " << z << "; regArray[" << z << "] = " << regArray[ z ] << endl;
ALUread = 1;
}
else if( ALUread == 1 )

{
ALUread = 0;
c2 = regArray[ z ];
c2 = c2 * 256;
c3 = c1 + c2;
cout << "c1: " << c1 << "; c2: " << c2 << "; c3: " << c3 << endl;
y = binaryDecimal( instruction.substr( 8, 4 ) );
y = regArray[ y ];
y = y - 2;
string str;
stringstream out;
out << c3;
str = out.str( );
Memory[ y ] = str;
cout << "Memory[" << y << "] = " << Memory[ y ] << "; y = " << y << endl;
}
void WriteBack( )
{
cout << "*************WRITEBACK********";
char temp[ 16 ];
if( MemtoReg == 1 )
WriteData = memData;
if( MemtoReg == 0 )
WriteData = ALUResult;
if( RegDst == 1 )
WriteReg = binaryDecimal( rd.c_str( ) );
if( RegDst == 0 )
WriteReg = binaryDecimal( rt.c_str( ) );
itoa( WriteData, temp, 10 );
cout << "WriteData: " << WriteData;

cout << "; WriteReg: " << WriteReg << "; RegDst: " << RegDst << "; Temp: " << temp << endl;
regArray[ WriteReg ] = WriteData;
cout << "RegArray[" << WriteReg << "]: " << regArray[ WriteReg ] << endl;
}

Team Leader: Srishti, Team Member: Krishna,: Ss878@msstate - Edu Kvt11@msstate - Edu

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Team Leader: Srishti, Team Member: Krishna,: Ss878@msstate - Edu Kvt11@msstate - Edu

Caricato da

Copyright:

Formati disponibili

Final Report for Team K

Team Leader: Srishti, ss878@msstate.edu

Team member: Krishna, kvt11@msstate.edu

2. Meetings (Oct 30 – December 1)

Name # of meetings # of attendance Contribution hours

3. Datapath with Control unit

a) Datapath without the new instructions:

6. Initial contents of the memory and register file at clock cycle 0

Memory (data + instructions):

Register File (data):

8. Output data from the simulation results:

1000 - Decode Opcode: 0010

The program, written using visual studio 2005 compiles successfully.

10. Final Version of Simulator Code (Attached)

//Opening and storing the input file into memory

Memory[ 1000 + i ] = memstring;

//Closing the input file

//Printing the initial memory contents to the screen

//Printing the initial register contents to the screen

//Printing the final register contents to the screen

//Printing the initial memory contents to the screen

int binaryDecimal( string memstring )

for( int i = memstring.size( ) - 1; i >= 0; i-- ) // < >

if( memstring[ i ] == '1' )

value = value + adder;

instruction = Memory[ programCounter ];

//Clearing the registers

//Opcode is first 4 bits of the instruction

cout << "Decode Opcode: " << opCode << endl;

if( opCode == "0000" ) // add

if( opCode == "0010" ) // add immediate

if( opCode == "0011" ) // load word

if( opCode == "0100" ) // store word

if( opCode == "0101" ) // and

if( opCode == "0110" ) // or

if( opCode == "0111" ) // lw immediate

if( opCode == "1000" ) // mult and accumulate

if( opCode == "1001" ) // or immediate

if( opCode == "1010" ) // shift left logical

if( opCode == "1011" ) // shift right logical

if( opCode == "1100" ) // branch on equal

if( opCode == "1101" ) // branch on not equal

if( opCode == "1110" ) // set on less than

if( opCode == "1111" ) // jump

void Execute( int state )

if( state == 3 ) // subtract

if( state == 4 ) // addi

if( state == 7 ) // and

if( state == 9 ) // lwi

if( state == 10 ) // mac

if( state == 11 ) // ori

if( state == 12 ) // shift left logical

if( state == 13 ) // shift right logical

if( state == 14 ) // branch on equal

if( state == 15 ) // branch on not equal

if( state == 16 ) // set on less than

if( state == 17 ) // jump

void funcALU( int ALUa, int ALUb )

if( ALUOp == 1 ) // sub

if( ALUOp == 3 || ALUOp == 6 ) // and

if( ALUOp == 4 || ALUOp == 7 ) // or, ori

if( ALUOp == 8 ) // sll

if( ALUOp == 9 ) // srl