testbranch.v

Use the verilog language write a MIPS CPU code, and have additional instruction, for example: select

`include "Single_cycle_cpu.v"

module testbrench;

	reg CLK;
	integer i;

	initial	
		begin
			CLK = 1'b0;
			repeat( 3000 ) #10 CLK <= ~CLK;

			$display("Sorted Data Memory\n");
			
			for( i = 0 ; i < 80 ; i = i + 4 )
				$display("%d\n",{ sort_cpu.DataMem.Mem[i+3], sort_cpu.DataMem.Mem[i+2], sort_cpu.DataMem.Mem[i+1], sort_cpu.DataMem.Mem[i] });
		end
//=============================================================================
//Un-Sorted-Data in Data Memory
//
//=============================================================================

	initial
		begin
		{ sort_cpu.DataMem.Mem[3], sort_cpu.DataMem.Mem[2], sort_cpu.DataMem.Mem[1], sort_cpu.DataMem.Mem[0] }	= 32'd5;
{ sort_cpu.DataMem.Mem[7], sort_cpu.DataMem.Mem[6], sort_cpu.DataMem.Mem[5], sort_cpu.DataMem.Mem[4] }	= 32'd22;
{ sort_cpu.DataMem.Mem[11], sort_cpu.DataMem.Mem[10], sort_cpu.DataMem.Mem[9], sort_cpu.DataMem.Mem[8] } = 32'd10;
{ sort_cpu.DataMem.Mem[15], sort_cpu.DataMem.Mem[14], sort_cpu.DataMem.Mem[13], sort_cpu.DataMem.Mem[12] } = 32'd100;
{ sort_cpu.DataMem.Mem[19], sort_cpu.DataMem.Mem[18], sort_cpu.DataMem.Mem[17], sort_cpu.DataMem.Mem[16] } = 32'd53;
{ sort_cpu.DataMem.Mem[23], sort_cpu.DataMem.Mem[22], sort_cpu.DataMem.Mem[21], sort_cpu.DataMem.Mem[20] } = 32'd14;
{ sort_cpu.DataMem.Mem[27], sort_cpu.DataMem.Mem[26], sort_cpu.DataMem.Mem[25], sort_cpu.DataMem.Mem[24] } = 32'd255;
{ sort_cpu.DataMem.Mem[31], sort_cpu.DataMem.Mem[30], sort_cpu.DataMem.Mem[29], sort_cpu.DataMem.Mem[28] } = 32'd188;
{ sort_cpu.DataMem.Mem[35], sort_cpu.DataMem.Mem[34], sort_cpu.DataMem.Mem[33], sort_cpu.DataMem.Mem[32] } = 32'd1111;
{ sort_cpu.DataMem.Mem[39], sort_cpu.DataMem.Mem[38], sort_cpu.DataMem.Mem[37], sort_cpu.DataMem.Mem[36] } = 32'd5498;
{ sort_cpu.DataMem.Mem[43], sort_cpu.DataMem.Mem[42], sort_cpu.DataMem.Mem[41], sort_cpu.DataMem.Mem[40] } = 32'd545;
{ sort_cpu.DataMem.Mem[47], sort_cpu.DataMem.Mem[46], sort_cpu.DataMem.Mem[45], sort_cpu.DataMem.Mem[44] } = 32'd2285;
{ sort_cpu.DataMem.Mem[51], sort_cpu.DataMem.Mem[50], sort_cpu.DataMem.Mem[49], sort_cpu.DataMem.Mem[48] } = 32'd132;
{ sort_cpu.DataMem.Mem[55], sort_cpu.DataMem.Mem[54], sort_cpu.DataMem.Mem[53], sort_cpu.DataMem.Mem[52] } = 32'd457;
{ sort_cpu.DataMem.Mem[59], sort_cpu.DataMem.Mem[58], sort_cpu.DataMem.Mem[57], sort_cpu.DataMem.Mem[56] } = 32'd775;
{ sort_cpu.DataMem.Mem[63], sort_cpu.DataMem.Mem[62], sort_cpu.DataMem.Mem[61], sort_cpu.DataMem.Mem[60] } = 32'd456;
{ sort_cpu.DataMem.Mem[67], sort_cpu.DataMem.Mem[66], sort_cpu.DataMem.Mem[65], sort_cpu.DataMem.Mem[64] } = 32'd875;
{ sort_cpu.DataMem.Mem[71], sort_cpu.DataMem.Mem[70], sort_cpu.DataMem.Mem[69], sort_cpu.DataMem.Mem[68] } = 32'd66;
{ sort_cpu.DataMem.Mem[75], sort_cpu.DataMem.Mem[74], sort_cpu.DataMem.Mem[73], sort_cpu.DataMem.Mem[72] } = 32'd75;
{ sort_cpu.DataMem.Mem[79], sort_cpu.DataMem.Mem[78], sort_cpu.DataMem.Mem[77], sort_cpu.DataMem.Mem[76] } = 32'd985;

//=============================================================================
//instruction in Instruction Memory
//	
//=============================================================================	
/*=============================================================================

for(i=0;i<size;i++){
	for(j=0;j<size-i;j++)
		if(list[j]<list[j+1])
             swap(list[i],list[j+1]);
}

Bubble_sort:
	addi $t0, $a0, 0		//t0 = A + 0;  t0 = i = 0;
	sll	$t1, $a1, 2	    	//t1 = 4 * size;   t1 = size;
    	addi $t2, $a0, 0    		//t2 = A + 0;      t2 = j = 0;
loop1:
	slt	$t8, $t0, $t1		//if(i < size) t8=1;
	beq	$t8, $zero, return	//if(i > size) return;
    	sub 	$t4, $t1, $t0	  	//t4 = t1 - t0        t4 = size - i;
loop2:
	slt	$t8, $t2, $t4		//if(j < size + 1);
	beq	$t8, $zero, exitloop2	//if(j > szie + 1) exit loop2;
   	adddi $t3, $t2, 4   		//t3 = t2 + 1      t3 = j + 1;
	sort $t7, $t2, $t3		//cmp( t2,t3 ) and swap;
    	addi $t2, $t2, 4    		//t2 = t2 + 1       t3 = j ++;
	j	loop2;
exitloop2:
	addi	$t0, $t0, 4		//i++
	addi	$t2, $a0, 0    		//t2 = A + 0;      t2 = j = 0;
	j	loop1;
return:
	
============================================================================*/
	sort_cpu.Register.REGISTER_BANK[4] = 32'd0;	//(a0)
	sort_cpu.Register.REGISTER_BANK[5] = 32'd20;	//(a1)
{ sort_cpu.InstMem.Mem[7], sort_cpu.InstMem.Mem[6], sort_cpu.InstMem.Mem[5], sort_cpu.InstMem.Mem[4] } = 32'b001000_00100_01000_0000000000000100;	//addi $t0, $a0, 0	
{ sort_cpu.InstMem.Mem[11], sort_cpu.InstMem.Mem[10], sort_cpu.InstMem.Mem[9],sort_cpu.InstMem.Mem[8] } = 32'b000000_00000_00101_01001_00010_000000;	//sll $t1, $a1, 2	t1 = (size) = 20
{ sort_cpu.InstMem.Mem[15], sort_cpu.InstMem.Mem[14], sort_cpu.InstMem.Mem[13],sort_cpu.InstMem.Mem[12] } = 32'b001000_00100_01010_0000000000000000;	//addi $t2, $a0, 0	t2 = j = 0
{ sort_cpu.InstMem.Mem[19], sort_cpu.InstMem.Mem[18], sort_cpu.InstMem.Mem[17],sort_cpu.InstMem.Mem[16] } = 32'b000000_01000_01001_11000_00000_101010;	//slt $t8, $t0, $t1	(loop1)
{ sort_cpu.InstMem.Mem[23], sort_cpu.InstMem.Mem[22], sort_cpu.InstMem.Mem[21],sort_cpu.InstMem.Mem[20] } = 32'b000100_11000_00000_0000000000001010;	//beq	$t8, $zero, return (20 + 4 + (4 * 10))(address 64)
{ sort_cpu.InstMem.Mem[27], sort_cpu.InstMem.Mem[26], sort_cpu.InstMem.Mem[25],sort_cpu.InstMem.Mem[24] } = 32'b000000_01001_01000_01100_00000_100010;	//sub $t4, $t1, $t0;
//{ sort_cpu.InstMem.Mem[31], sort_cpu.InstMem.Mem[30], sort_cpu.InstMem.Mem[29],sort_cpu.InstMem.Mem[28] } = 32'b001000_00100_01010_0000000000000000;	//addi	$t2, $a0, 0
{ sort_cpu.InstMem.Mem[31], sort_cpu.InstMem.Mem[30], sort_cpu.InstMem.Mem[29],sort_cpu.InstMem.Mem[28] } = 32'b000000_01010_01100_11000_00000_101010;	//slt	$t8, $t2, $t4 (loop2)
{ sort_cpu.InstMem.Mem[35], sort_cpu.InstMem.Mem[34], sort_cpu.InstMem.Mem[33],sort_cpu.InstMem.Mem[32] } = 32'b000100_11000_00000_0000000000000101;	//beq	$t8, $zero, exitloop2 (32 + 4 + (4 * 5)) (address 56)
{ sort_cpu.InstMem.Mem[39], sort_cpu.InstMem.Mem[38], sort_cpu.InstMem.Mem[37],sort_cpu.InstMem.Mem[36] } = 32'b001000_01010_01011_0000000000000100;	//adddi $t3, $t2, 4
{ sort_cpu.InstMem.Mem[43], sort_cpu.InstMem.Mem[42], sort_cpu.InstMem.Mem[41],sort_cpu.InstMem.Mem[40] } = 32'b100111_01010_01011_01111_00000_101010;	//sort $t7, $t2, $t3	
{ sort_cpu.InstMem.Mem[47], sort_cpu.InstMem.Mem[46], sort_cpu.InstMem.Mem[45],sort_cpu.InstMem.Mem[44] } = 32'b001000_01010_01010_0000000000000100;	//addi $t2, $t2, 4	
{ sort_cpu.InstMem.Mem[51], sort_cpu.InstMem.Mem[50], sort_cpu.InstMem.Mem[49],sort_cpu.InstMem.Mem[48] } = 32'b000010_00000000000000000000000111;	//j	loop2; (7 * 4 = 28)
{ sort_cpu.InstMem.Mem[55], sort_cpu.InstMem.Mem[54], sort_cpu.InstMem.Mem[53],sort_cpu.InstMem.Mem[52] } = 32'b000000_01011_00000_01010_00000_100000;	//addi	$t0, $t0, 4 (exitloop2)
{ sort_cpu.InstMem.Mem[59], sort_cpu.InstMem.Mem[58], sort_cpu.InstMem.Mem[57],sort_cpu.InstMem.Mem[56] } = 32'b001000_00100_01010_0000000000000000;	//addi	$t2, $a0, 0//addi	$t2, $a0, 0
{ sort_cpu.InstMem.Mem[63], sort_cpu.InstMem.Mem[62], sort_cpu.InstMem.Mem[61],sort_cpu.InstMem.Mem[60] } = 32'b000010_00000000000000000000000100;	//j	loop1; (4 * 4 = 16)
{ sort_cpu.InstMem.Mem[67], sort_cpu.InstMem.Mem[66], sort_cpu.InstMem.Mem[65],sort_cpu.InstMem.Mem[64] } = 32'b001000_00100_01000_0000000000000100;	//addi $t0, $a0, 0
//{ sort_cpu.InstMem.Mem[67], sort_cpu.InstMem.Mem[66], sort_cpu.InstMem.Mem[65],sort_cpu.InstMem.Mem[64] } = 32'b;//
//{ sort_cpu.InstMem.Mem[71], sort_cpu.InstMem.Mem[70], sort_cpu.InstMem.Mem[69],sort_cpu.InstMem.Mem[68] } = 32'b;//	
		end

	always@ ( posedge CLK )
		$display("%d",sort_cpu.PC_NewAddress);
	
	always@ ( sort_cpu.swap ) begin
		$display("cmp %b",sort_cpu.cmp);
		$display("swap %b",sort_cpu.swap);
		$display("data1:%d  data2:%d",sort_cpu.Read_data1, sort_cpu.Read_data2);
	end

	Single_cycle_cpu sort_cpu(CLK);

endmodule