Matrix Multiplication Final Project!

.gitignore

@@ -0,0 +1,12 @@
+# Ignore compiled binaries
+*
+!/**/
+!*.*
+!makefile
+*.out
+
+# Ignore gtkwave files
+*.vcd
+
+# Ignore temporary memory file
+mem.dat

6by6multiply.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+python2 setup_memory.py
+
+cat data_test.dat > matrix_mem.dat
+cat prog_test.dat > prog_mem.dat
+
+echo "Running the BIG test..."
+make
+./multiplier6by6
+
+python2 read_6by6result.py
+
+make clean

ProjectProposal.md

@@ -0,0 +1,36 @@
+# GPU Matrix Operations
+### Ariana Olson, Rocco DiVerdi, Serena Chen
+
+We want to study GPU architectures, and build a simple one to do matrix operations. We want to understand the strategy for multiplying matrices in the GPU, and how the GPU is programmed to perform these operations. We will also build a small toy matrix multiplier module in verilog, which can be scaled in scope depending on how much time the previous parts of the project take.
+
+## References:
+
+[Understanding the Efficiency of GPU Algorithms for Matrix-Matrix Multiplication](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.1.6823&rep=rep1&type=pdf)
+
+[Matrix computations on the GPU](https://developer.nvidia.com/sites/default/files/akamai/cuda/files/Misc/mygpu.pdf) 
+
+[Matrix Multiplication with CUDA — A basic introduction to the CUDA programming model](https://www.shodor.org/media/content/petascale/materials/UPModules/matrixMultiplication/moduleDocument.pdf)
+
+[some random project from somewhere making a GPU](https://courses.cs.washington.edu/courses/cse467/15wi/docs/prj1.pdf)
+
+## MVP: 
+
+Present to class about how GPUs perform matrix multiplication and other operations. And how it compares to MIPS CPU.
+
+Planned: Build a toy processor that performs operations and prints results to the terminal.
+
+Stretch: Visualize real time matrix transformations for a small set of “pixels”
+
+Super Stretch: be hired by Nvidia
+
+Even more super stretch: start a GPU company and make Nvidia obsolete 
+
+## Work Plan:
+
+Thanksgiving break: sleep
+
+11/27-12/3: Learn about matrix multiplication on GPUs, run some example programs on actual GPUs. Set up documentation framework. Start writing up explanations of what we have learned.
+
+12/4-12/10: Start implementing verilog modules. Create documentation on performance, how to run tests/examples, block diagrams, etc.
+
+12/10-12/14: Debugging, polishing, documenting. (try not to be dead)

add3by3.t.v

@@ -0,0 +1,61 @@
+/*
+Test bench for 3 by 3 matrix adder
+*/
+
+`include "add3by3.v"
+
+module add3by3_TEST();
+	parameter ENTRY_SIZE = 9;
+
+	reg[ENTRY_SIZE - 1:0] a0, a1, a2, a3, a4;
+	reg[ENTRY_SIZE - 1:0] a5, a6, a7, a8;
+	reg[ENTRY_SIZE - 1:0] b0, b1, b2, b3, b4;
+	reg[ENTRY_SIZE - 1:0] b5, b6, b7, b8;
+	wire[ENTRY_SIZE - 1:0] c0, c1, c2, c3, c4;
+	wire[ENTRY_SIZE - 1:0] c5, c6, c7, c8;
+
+	add3by3 #(.ENTRY_SIZE(ENTRY_SIZE)) dut (
+		.a0(a0), .a1(a1), .a2(a2), .a3(a3), .a4(a4),
+		.a5(a5), .a6(a6), .a7(a7), .a8(a8), .b0(b0),
+		.b1(b1), .b2(b2), .b3(b3), .b4(b4), .b5(b5),
+		.b6(b6), .b7(b7), .b8(b8), .c0(c0), .c1(c1),
+		.c2(c2), .c3(c3), .c4(c4), .c5(c5), .c6(c6),
+		.c7(c7), .c8(c8)
+	);
+
+	initial begin
+	 	// Add two matrices
+		a0 = 1; a1 = 2; a2 = 3; a3 = 4; a4 = 5; a5 = 6; a6 = 7; a7 = 8; a8 = 9;
+	  	b0 = 30; b1 = 29; b2 = 28; b3 = 27; b4 = 26; b5 = 25; b6 = 24; b7 = 23; b8 = 22;
+
+	  	#50
+
+		if (c0 !== 5'd31) begin
+			$display("Test case failed.\nExpected value of c0: %b\tActual value of c0: %b", a0 + b0, c0);
+		end
+		if (c1 !== 5'd31) begin
+			$display("Test case failed.\nExpected value of c1: %b\tActual value of c1: %b", a1 + b1, c1);
+		end
+		if (c2 !== 5'd31) begin
+			$display("Test case failed.\nExpected value of c2: %b\tActual value of c2: %b", a2 + b2, c2);
+		end
+		if (c3 !== 5'd31) begin
+			$display("Test case failed.\nExpected value of c3: %b\tActual value of c3: %b", a3 + b3, c3);
+		end
+		if (c4 !== 5'd31) begin
+			$display("Test case failed.\nExpected value of c4: %b\tActual value of c4: %b", a4 + b4, c4);
+		end
+		if (c5 !== 5'd31) begin
+			$display("Test case failed.\nExpected value of c5: %b\tActual value of c5: %b", a5 + b5, c5);
+		end
+		if (c6 !== 5'd31) begin
+			$display("Test case failed.\nExpected value of c6: %b\tActual value of c6: %b", a6 + b6, c6);
+		end
+		if (c7 !== 5'd31) begin
+			$display("Test case failed.\nExpected value of c7: %b\tActual value of c7: %b", a7 + b7, c7);
+		end
+		if (c8 !== 5'd31) begin
+			$display("Test case failed.\nExpected value of c8: %b\tActual value of c8: %b", a8 + b8, c8);
+		end
+	end
+endmodule

add3by3.v

@@ -0,0 +1,41 @@
+/*
+Add two 3 by 3 matrix blocks. 	
+Performs the operation A + B = C
+
+Entries 0 to 8
+of all matrices are arranged in the following order:
+
+	x0	x1	x2
+	x3	x4	x5
+	x6	x7	x8
+
+Inputs:
+	- a0, ..., a8: the entries of matrix A
+	- b0, ..., a8: the entries of matrix B
+Outputs:
+	- c0, ..., c8: the entries of matrix C
+Parameters:
+	- ENTRY_SIZE: the number of bits of each matrix entry
+*/
+
+module add3by3
+#(
+	parameter ENTRY_SIZE = 5
+)(
+	input[ENTRY_SIZE - 1:0] a0, a1, a2, a3,
+	input[ENTRY_SIZE - 1:0] a4, a5, a6, a7, a8,
+	input[ENTRY_SIZE - 1:0] b0, b1, b2, b3,
+	input[ENTRY_SIZE - 1:0] b4, b5, b6, b7, b8,
+	output[ENTRY_SIZE - 1:0] c0, c1, c2, c3,
+	output[ENTRY_SIZE - 1:0] c4, c5, c6, c7, c8
+);
+	assign c0 = a0 + b0;
+	assign c1 = a1 + b1;
+	assign c2 = a2 + b2;
+	assign c3 = a3 + b3;
+	assign c4 = a4 + b4;
+	assign c5 = a5 + b5;
+	assign c6 = a6 + b6;
+	assign c7 = a7 + b7;
+	assign c8 = a8 + b8;
+endmodule

arithmetic.t.v

@@ -0,0 +1,42 @@
+/*
+Test bench for the scalar multiplication module
+*/
+
+`include "arithmetic.v"
+module scalar_multiplication_TEST();
+
+parameter ENTRY_SIZE = 5;
+parameter RESENTRY_SIZE = 9;
+
+reg[ENTRY_SIZE - 1:0] a, b;
+wire[RESENTRY_SIZE - 1:0] out;
+
+scalar_multiplication #(.ENTRY_SIZE(ENTRY_SIZE), .RESENTRY_SIZE(RESENTRY_SIZE)) dut (a, b, out);
+
+initial begin
+	// Multiply by 0
+	a = 5'd0; b = 5'd0; #50
+	if (out !== 9'd0) begin
+		$display("Test failed. Expected output: %b. Actual output: %b", 9'd0, out);
+	end
+
+	// Multiply by 1
+	a = 5'd1; b = 5'd15; #50
+	if (out !== 9'd15) begin
+		$display("Test failed. Expected output: %b. Actual output: %b", 9'd15, out);
+	end
+
+	// Multiply two numbers that do not overflow the result size
+	a = 5'd25; b = 5'd20; #50
+	if (out !== 9'd500) begin
+		$display("Test failed. Expected output: %b. Actual output: %b", 9'd500, out);
+	end
+
+	// Multiply two numbers that overflow the result size
+	// Expect the most significant bits to be truncated
+	a = 5'd31; b = 5'd25; #50
+	if (out !== 9'd263) begin
+		$display("Test failed. Expected output: %b. Actual output: %b", 9'd263, out);
+	end
+end
+endmodule // testMult

arithmetic.v

@@ -0,0 +1,24 @@
+/*
+Performs a scalar multiplication on two numbers.
+Represents the operation a * b = c.
+Inputs: 
+	- a and b are the two scalars being multiplied
+Outputs: 
+	- result is the scalar product.
+Parameters:
+	- ENTRY_SIZE is the size of a and b
+	- RESENTRY_SIZE is the size of result
+*/
+module scalar_multiplication 
+#(
+	parameter ENTRY_SIZE = 5,
+	parameter RESENTRY_SIZE = 9
+)
+(
+	input [ENTRY_SIZE - 1:0] a, b,
+	output [RESENTRY_SIZE - 1:0] result
+);
+
+assign result = a*b;
+
+endmodule // multiplication

block_test_data.dat

@@ -0,0 +1,73 @@
+// This is the memory that should be used in the load block test
+
+// 3 by 3 identity at address 0
+0_0001
+0_0000
+0_0000
+0_0000
+0_0001
+0_0000
+0_0000
+0_0000
+0_0001
+
+// 4 by 4 increasing at address 9
+0_0000
+0_0001
+0_0010
+0_0011
+0_0100
+0_0101
+0_0110
+0_0111
+0_1000
+0_1001
+0_1010
+0_1011
+0_1100
+0_1101
+0_1110
+0_1111
+
+// 7 by 3 decreasing at address 25
+1_1111
+1_1110
+1_1101
+1_1100
+1_1011
+1_1010
+1_1001
+1_1000
+1_0111
+1_0110
+1_0101
+1_0100
+1_0011
+1_0010
+1_0001
+1_0000
+0_1111
+0_1110
+0_1101
+0_1100
+0_1011
+
+// Extra memory at address 46
+0_0000
+0_0000
+0_0000
+0_0000
+0_0000
+0_0000
+0_0000
+0_0000
+0_0000
+0_0000
+0_0000
+0_0000
+0_0000
+0_0000
+0_0000
+0_0000
+0_0000
+0_0000