Caminho Dados com Pipeline

Caminho Dados com Pipeline


DisciplinaArquitetura e Organização de Computadores1.252 materiais7.461 seguidores
Pré-visualização24 páginas
Caminho Dados com Pipeline/Relatório TP01 OC2.docx
UNIVERSIDADE FEDERAL DE VIÇOSA \u2013 UFV
CAMPUS FLORESTAL-MG
Juliana Rezende Silveira Baia Alves \u2013 1787
Wandella Maia de Oliveira\u2013 2292
Caminho de Dados do MIPS Pipeline
Relatório do Trabalho Prático 01
Florestal, 2016
Juliana Rezende Silveira Baia Alves
Wandella Maia de Oliveira
Caminho de Dados do MIPS Pipeline
Relatório técnico do primeiro trabalho prático da disciplina Organização de Computadores 2, do Curso Ciência da Computação, da Universidade Federal de Viçosa \u2013 Campus Florestal.
 
Prof. Dr. José Augusto Miranda Nacif
Florestal, 2016
RESUMO
 	Este trabalho apresenta a implementação do Caminho de Dados do MIPS com Pipeline. Para o desenvolvimento do trabalho será utilizado a linguagem de descrição de hardware (HDL), Verilog. O objetivo é relatar de forma simples como foi realizado cada um dos passos citados e apresentar os resultados.
1 \u2013 INTRODUÇÃO
Pipeline é uma técnica de implementação de processadores que permite aumentar as instruções de forma que possam ser executadas simultaneamente e as instruções iniciadas, são terminadas por unidades de tempo. 
Essas unidades são separadas em fases, cada uma responsável por uma função.
Os passos para a elaboração do trabalho foram:
Abstrair o funcionamento do Pipeline
Implementar um código em verilog
Simular em formas de ondas
2 - DESENVOLVIMENTO 
2.1 CAMINHO DE DADOS COM PIPELINE
O Caminho de Dados do MIPS consiste em adicionar novas instruções com os estágios do Pipeline. A técnica citada leva muito menos tempo, pois quando uma seção finaliza, a outra começa e isso faz com que no final de toda execução, o tempo gasto seja menor.
O Pipeline é dividido em cinco estágios, significa que até cinco instruções serão executadas durante qualquer ciclo de clock.
O Caminho de Dados deve ser divido em cinco partes, com cada parte possuindo um nome correspondente a um estagio da execução de instrução:
IF: Busca de instruções.
ID: Decodificação de instruções e leitura do banco de registradores.
EX: Execução ou calculo de endereço.
MEM: Acesso á memoria de dados.
WB: Escrita do resultado.
Figura 1 Caminho de Dados MIPS com Estágios do Pipeline
 
2.2 CÓDIGO EM LINGUAGEM HARDWARE
Figura 2 Estagio IFID-A instrução é lida da memoria usando o endereço do PC e depois colocada no registrador de pipeline IFID. 
Figura 3 EstagioIDEX-A instrução no registrador de pipeline IFID fornece os números de dois registradores para leitura e estende o sinal do imediato de 16 bits. Esses três valores de 32 bits são armazenados no registrador de pipeline IDEX.
Figura 4 Estagio MEMWB-Os dados durante o estagio MEM é colocar os dados no registrador de pipeline. No estagio WB especifica o registrador a ser escrito.
Figura 5 Unidade de Hazard
Figura 6 Unidade de Forwarding
2.3 FORMAS DE ONDAS
O trabalho utiliza a linguagem de descrição de hardware (HDL), no caso é o Verilog. Ao utilizar a ferramenta IcarusVerilog, é gerado um arquivo que o Gtkwave interpreta como forma de onda, que por sua vez faclita a compreensão do resultado.
Figura 7 Forma de Ondas
3 \u2013 CONCLUSÃO
	A prática do trabalho serviu para estimular o real entendimento de parte da matéria e fez com que adquiríssemos novas habilidades e um maior entendimento na síntese do Verilog.
Além disso, a aplicação do trabalho mostra a importância do trabalho em equipe. Logo, isso ensina a organizar tarefas e principalmente organizar ideias com colegas.
4 - REFERÊNCIAS BIBLIOGRÁFICAS
1. GTKWAVE
2. HENNESSY, J. L., PATTERSON, D. A. Organização e Projeto de Computadores. Campus, 3ª ed., 2005.
3. Bloco de notas
4. IcarusVerilog
		10
Caminho Dados com Pipeline/controleALU.v
module ALUControl(andi,ori,addi,ALUOp,funct,ALUCon);
input [1:0] ALUOp;
input [5:0] funct;
input andi,ori,addi;
output [3:0] ALUCon;
reg [3:0] ALUCon;
	//CONTROLE FUNÇOES
	always@(ALUOp or funct or andi or ori or addi)
		begin
			case(ALUOp)
			2'b00://lw or sw
			ALUCon = 4'b0010;
			2'b01://beq
			ALUCon = 4'b0110;
			2'b10://R-type
		begin
		if(funct==6'b100100)
			ALUCon = 4'b0000;//and
		if(funct==6'b100101)
			ALUCon = 4'b0001;//or
		if(funct==6'b100000)
			ALUCon = 4'b0010;//add
		if(funct==6'b011000)
			ALUCon = 4'b0011;//multi
		if(funct==6'b100111)
			ALUCon = 4'b0100;//nor
		if(funct==6'b011010)
			ALUCon = 4'b0101;//div
		if(funct==6'b100010)
			ALUCon = 4'b0110;//sub
		if(funct==6'b101010)
			ALUCon = 4'b0111;//slt
		end
			2'b11://immediate
		begin
		if(andi)begin
			ALUCon = 4'b0000;//andi
		end
		if(ori) begin
			ALUCon = 4'b0001;//ori
		end
		if(addi)
			ALUCon = 4'b0010;//addi
		end
			endcase
	end
endmodule
Caminho Dados com Pipeline/controlepipeline.v
module Control(Op,Out,j,bne,imm,andi,ori,addi);
input [5:0] Op;
output[8:0] Out;
output j,bne,imm,andi,ori,addi;
wire regdst,alusrc,memtoreg,regwrite,memread,memwrite,branch;
//tipos de instruçao
wire r = ~Op[5]&~Op[4]&~Op[3]&~Op[2]&~Op[1]&~Op[0];
wire lw = Op[5]&~Op[4]&~Op[3]&~Op[2]&Op[1]&Op[0];
wire sw = Op[5]&~Op[4]&Op[3]&~Op[2]&Op[1]&Op[0];
wire beq = ~Op[5]&~Op[4]&~Op[3]&Op[2]&~Op[1]&~Op[0];
wire bne = ~Op[5]&~Op[4]&~Op[3]&Op[2]&~Op[1]&Op[0];
wire j = ~Op[5]&~Op[4]&~Op[3]&~Op[2]&Op[1]&~Op[0];
wire andi = ~Op[5]&~Op[4]&Op[3]&Op[2]&~Op[1]&~Op[0];
wire ori = ~Op[5]&~Op[4]&Op[3]&Op[2]&~Op[1]&Op[0];
wire addi = ~Op[5]&~Op[4]&Op[3]&~Op[2]&~Op[1]&~Op[0];
wire imm = andi|ori|addi; //valor imediato
//controles separados por referencias
wire [3:0] EXE;
wire [2:0] M;
wire [1:0] WB;
	// microcode control
		assign regdst = r;
		assign alusrc = lw|sw|imm;
		assign memtoreg = lw;
		assign regwrite = r|lw|imm;
		assign memread = lw;
		assign memwrite = sw;
		assign branch = beq;
	// EXE control
		assign EXE[3] = regdst;
		assign EXE[2] = alusrc;
		assign EXE[1] = r;
		assign EXE[0] = beq;
	//M controle
		assign M[2] = branch;
		assign M[1] = memread;
		assign M[0] = memwrite;
	//WB controle
		assign WB[1] = memtoreg;
		assign WB[0] = regwrite;
	//output controle
		assign Out[8:7] = WB;
		assign Out[6:4] = M;
		assign Out[3:0] = EXE;
endmodule
Caminho Dados com Pipeline/mux.v
module BIGMUX2(A,X0,X1,X2,X3,Out);//non-clocked mux
input [1:0] A;
input [31:0] X3,X2,X1,X0;
output [31:0] Out;
reg [31:0] Out;
always@(A,X3,X2,X1,X0)
	begin
		case(A)
		2'b00:
		Out <= X0;
		2'b01:
		Out <= X1;
		2'b10:
		Out <= X2;
		2'b11:
		Out <= X3;
		endcase
	end
endmodule
Caminho Dados com Pipeline/MUX_2.v
module MUX_2(instrucao1 ,instrucao2,RedDst,EscreveReg);
input [4:0]instrucao1, instrucao2;
input RedDst;
output [4:0]EscreveReg;
reg [4:0]EscreveReg;
always@(instrucao1,instrucao2,RedDst)
	begin
		case(RedDst)
		
		1'b0: EscreveReg= instrucao1;
		1'b1: EscreveReg=instrucao2;
		endcase
	
	end
endmodule
Caminho Dados com Pipeline/PC.v
module PC(clock,pc,pcnovo);
	input clock;
	output [31:0] pc;
	output [31:0] pcnovo;
	contadorprograma conte(clock,pcnovo,pc);
	Somador pcquatro(pc,pcnovo);
	
	
endmodule
module contadorprograma(clock,pcnovo,pc);
	input [31:0] pcnovo; //Converte para 32 bits
	input clock;
	output [31:0] pc;
	reg [31:0] pc;
	initial begin
	pc=32'b00000000000000000000000000000000;
	end
	always @(posedge clock)
	begin
	pc = pcnovo;
	end
endmodule
module Somador(pc,pcnovo);
	input [31:0] pc;
	output [31:0] pcnovo;
	assign pcnovo= pc+32'b00000000000000000000000000000100;