qazwyc

Verilog 数字电路设计之带hazard的五级流水线CPU

设计目标

指令组成

一条指令由16bits组成，高5位是操作码，代表不同的操作类型；低11位是操作数，分为3部分，10:8位作为标号，代表寄存器堆里的某一个寄存器；3:0位与7:4位既可以像10:8位一样作为寄存器标号，也可以作为具体的某一个数值（称为立即数），具体根据指令来区分。

数据访问

简易CPU指令集

五级流水线

框图

Hazard

Data Hazard
- Arithmetic
  
  Solution： Data forwarding
- LOAD
  
  Solution: Stall+Data forwarding
Control Hazard
During the time from branch instruction fetch to branch address generate (from IF to ID to EX to MEM, 3 stages), the 3 instructions followed by branch are in pipeline.
Solution: Flush

Verilog代码

顶层模块cpu.v

module cpu( input wire clk, enable, reset, start
); 

wire [15:0] d_datain; //data from memory 
wire [15:0] i_datain; //instruction
wire [7:0] d_addr;    //address for data memory
wire [15:0] d_dataout;//output data to data memory
wire d_we;            //write dm enable 
wire [7:0] i_addr;    //pc

PCPU pcpu(
    .clock(clk),
    .enable(enable),
    .reset(reset),
    .start(start),
    .d_datain(d_datain),
    .i_datain(i_datain),
    .d_addr(d_addr),
    .d_dataout(d_dataout),
    .d_we(d_we),
    .i_addr(i_addr)
);

I_mem i_mem(
    .addra(i_addr),
    .douta(i_datain)
);

D_mem d_mem(
    .wea(d_we),
    .addra(d_addr),
    .dina(d_dataout),
    .douta(d_datain)
);

endmodule

头文件headfile.v

`ifndef HEADFILE_H_

`define idle 1'b0
`define exec 1'b1
`define NOP 5'b00000
`define HALT 5'b00001
`define LOAD 5'b00010
`define STORE 5'b00011
`define SLL 5'b00100
`define SLA 5'b00101
`define SRL 5'b00110
`define SRA 5'b00111
`define ADD 5'b01000
`define ADDI 5'b01001
`define SUB 5'b01010
`define SUBI 5'b01011
`define CMP 5'b01100
`define AND 5'b01101
`define OR 5'b01110
`define XOR 5'b01111
`define LDIH 5'b10000
`define ADDC 5'b10001
`define SUBC 5'b10010
`define JUMP 5'b11000
`define JMPR 5'b11001
`define BZ 5'b11010
`define BNZ 5'b11011
`define BN 5'b11100
`define BNN 5'b11101
`define BC 5'b11110
`define BNC 5'b11111
`define gr0 3'b000
`define gr1 3'b001
`define gr2 3'b010
`define gr3 3'b011
`define gr4 3'b100
`define gr5 3'b101
`define gr6 3'b110
`define gr7 3'b111 

`endif

流水线cpu代码pcpu.v

`include "headfile.v"

module PCPU(input wire reset, enable, clock, start,
    input wire [15:0] d_datain,  //data from memory 
    i_datain,                    //instruction
    output wire [7:0] d_addr,    //address for data memory 
    output wire [7:0] i_addr,    //pc
    output wire [15:0] d_dataout,//output data to data memory 
    output wire d_we             //write enable 
    );
reg state,next_state;  //to control the CPU  
reg [7:0] pc;
reg [15:0] id_ir,ex_ir,mem_ir,wb_ir;
reg [15:0] reg_A, reg_B, reg_C, reg_C1, smdr, smdr1, ALUo; 
reg dw, zf, nf, cf, cin;
reg [15:0] gr[0:7];
assign d_dataout = smdr1;
assign d_we = dw;
assign d_addr = reg_C[7:0];
assign i_addr = pc;
//************* CPU control *************//
always @(posedge clock or negedge reset)
    begin
        if (!reset)
            state <= `idle;
        else
            state <= next_state;
    end
always @(*)
    begin
        case (state)
            `idle : 
                if ((enable == 1'b1) && (start == 1'b1)) // on
                    next_state <= `exec;
                else    
                    next_state <= `idle;
            `exec :
                if ((enable == 1'b0) || (wb_ir[15:11] == `HALT))//pause
                    next_state <= `idle;
                else
                    next_state <= `exec;
        endcase
    end

//************* IF *************// 取址
always @(posedge clock or negedge reset)
    begin
        if (!reset)
            begin
                id_ir <= 16'b0000_0000_0000_0000;
                pc <= 8'b0000_0000;
            end

        else if (state ==`exec)
            begin   
            if((ex_ir[15:11] == `BZ && zf == 1'b1) || (ex_ir[15:11] == `BN && nf == 1'b1)
                    ||(ex_ir[15:11] == `BNZ && zf == 1'b0) || (ex_ir[15:11] == `BNN && nf == 1'b0)
                     ||(ex_ir[15:11] == `BC && cin == 1'b1) || (ex_ir[15:11] == `BNC && cin == 1'b0)
                     || ex_ir[15:11] == `JMPR)
                    begin
                       pc <= ALUo[7:0];
                       id_ir <= 16'bx;//flush
                   end
                else if(id_ir[15:11] == `JUMP)
                   begin
                  pc <= id_ir[7:0]; //jump to {val2,val3}
                       id_ir <= 16'bx;
               end
                else if(id_ir[15:11] == `HALT) // STOP
                    begin 
                       pc <= pc; 
                       id_ir <= id_ir; 
                    end     
            //Load hazard  Stall    
                else if((id_ir[15:11] == `LOAD)&&(i_datain[15:11]!=`JUMP)&&(i_datain[15:11]!=`NOP)&&(i_datain[15:11]!=`HALT)
                  &&(i_datain[15:11]!=`LOAD)) 
                 begin
                      //r1
                   if((id_ir[10:8]==i_datain[2:0])&&((i_datain[15:11]==`ADD)||(i_datain[15:11]==`ADDC)
                       ||(i_datain[15:11]==`SUB)||(i_datain[15:11]==`SUBC)||(i_datain[15:11]==`CMP)||(i_datain[15:11]==`AND)
                        ||(i_datain[15:11]==`OR)||(i_datain[15:11]==`XOR)))
                       begin
                         pc <= pc;
                         id_ir <= 16'bx;
                       end
                      //r2
                    else if((id_ir[10:8]==i_datain[6:4])&&((i_datain[15:11]==`STORE)||(i_datain[15:11]==`ADD)
                      ||(i_datain[15:11]==`ADDC)||(i_datain[15:11]==`SUB)||(i_datain[15:11]==`SUBC)||(i_datain[15:11]==`AND)
                        ||(i_datain[15:11]==`OR)||(i_datain[15:11]==`XOR)||(i_datain[15:11]==`CMP)||(i_datain[15:11]==`SLL)
                        ||(i_datain[15:11]==`SRL)||(i_datain[15:11]==`SLA)||(i_datain[15:11]==`SRA)))
                       begin
                         pc <= pc;
                         id_ir <= 16'bx;
                       end
                      //r3
                   else if((id_ir[10:8]==i_datain[10:8])&&((i_datain[15:11]==`STORE)||(i_datain[15:11]==`LDIH)
                      ||(i_datain[15:11]==`SUBI)||(i_datain[15:11]==`JMPR)||(i_datain[15:11]==`BZ)||(i_datain[15:11]==`BNZ)
                       ||(i_datain[15:11]==`BN)||(i_datain[15:11]==`BNN)||(i_datain[15:11]==`BNC)||(i_datain[15:11]==`BNC)))
                       begin
                         pc <= pc;
                         id_ir <= 16'bx;
                       end
                      else
                         begin
                            pc <= pc + 1'b1;
                         id_ir <= i_datain;
                          end
                   end
                else
                   begin
                       pc <= pc + 1'b1;
                       id_ir <= i_datain;
                    end
            end
         else if(state==`idle)
                begin
                   id_ir <= id_ir;
                    pc <= pc;
                end         
    end
//************* ID *************//译码
always @(posedge clock or negedge reset)
    begin
        if (!reset)
            begin
                ex_ir <= 16'b0000_0000_0000_0000;
                reg_A <= 16'b0000_0000_0000_0000;
                reg_B <= 16'b0000_0000_0000_0000; 
                smdr <= 16'b0000_0000_0000_0000;
            end
        //flush
        else if(state == `exec && ((ex_ir[15:11]==`BZ && zf==1'b1) ||(ex_ir[15:11]==`BNZ && zf==1'b0) 
              ||(ex_ir[15:11]==`BN && nf==1'b1) || (ex_ir[15:11]==`BNN && nf==1'b0) ||(ex_ir[15:11]==`BC && cin==1'b1)
            ||(ex_ir[15:11]==`BNC && cin==1'b0) || ex_ir[15:11]==`JMPR))
              ex_ir <= 16'bx;

      else if (state == `exec)
            begin
                ex_ir <= id_ir;
               //regA
               //r1=r1+{val2,val3}
                if ((id_ir[15:11] == `BZ) || (id_ir[15:11] == `BNZ) || (id_ir[15:11] == `BN) || (id_ir[15:11] == `BNN) 
                  || (id_ir[15:11] == `BC) || (id_ir[15:11] == `BNC) || (id_ir[15:11] == `LDIH) || (id_ir[15:11] == `ADDI) 
                  || (id_ir[15:11] == `SUBI) || (id_ir[15:11] == `JMPR)) 
                  begin
                    //r1未写回
                   if(id_ir[10:8]==ex_ir[10:8]&&(ex_ir[15:11] == `ADD || ex_ir[15:11] == `LDIH || ex_ir[15:11] == `ADDI || ex_ir[15:11] == `SUB
                          || ex_ir[15:11] == `SUBI || ex_ir[15:11] == `ADDC || ex_ir[15:11] == `SUBC || ex_ir[15:11] == `AND 
                          || ex_ir[15:11] == `OR || ex_ir[15:11] == `XOR || ex_ir[15:11] == `SLL || ex_ir[15:11] == `SRL
                          || ex_ir[15:11] == `SLA || ex_ir[15:11] == `SRA ))
                       reg_A <= ALUo; 
                    else if(id_ir[10:8] == mem_ir[10:8]&&(mem_ir[15:11] == `ADD || mem_ir[15:11] == `LDIH || mem_ir[15:11] == `ADDI 
                            || mem_ir[15:11] == `SUB || mem_ir[15:11] == `SUBI || mem_ir[15:11] == `ADDC 
                             || mem_ir[15:11] == `SUBC || mem_ir[15:11] == `AND || mem_ir[15:11] == `OR || mem_ir[15:11] == `XOR 
                             || mem_ir[15:11] == `SLL || mem_ir[15:11] == `SRL || mem_ir[15:11] == `SLA || mem_ir[15:11] == `SRA 
                             || mem_ir[15:11] == `LOAD))
                             begin
                                 if(mem_ir[15:11]==`LOAD)  //load是否出结果
                               reg_A <= d_datain;
                            else
                              reg_A <= reg_C;  
                       end
               else if(wb_ir[10:8] == id_ir[10:8]&&(wb_ir[15:11] == `ADD || wb_ir[15:11] == `LDIH || wb_ir[15:11] == `ADDI 
                           || wb_ir[15:11] == `SUB || wb_ir[15:11] == `SUBI || wb_ir[15:11] == `ADDC || wb_ir[15:11] == `SUBC 
                             || wb_ir[15:11] == `AND || wb_ir[15:11] == `OR || wb_ir[15:11] == `XOR || wb_ir[15:11] == `SLL 
                             || wb_ir[15:11] == `SRL || wb_ir[15:11] == `SLA || wb_ir[15:11] == `SRA || wb_ir[15:11] == `LOAD ))
                       reg_A <= reg_C1;                 
                    else
                       reg_A <= gr[(id_ir[10:8])];//gr1
                  end
                //r1=r2#r3 or r1=r2#val 
                else if(id_ir[15:11] == `LOAD || id_ir[15:11] == `STORE || id_ir[15:11] == `ADD || id_ir[15:11] == `SUB 
                        || id_ir[15:11] == `ADDC || id_ir[15:11] == `SUBC || id_ir[15:11] == `CMP || id_ir[15:11] == `AND 
                          || id_ir[15:11] == `OR || id_ir[15:11] == `XOR || id_ir[15:11] == `SLL || id_ir[15:11] == `SRL 
                          || id_ir[15:11] == `SLA || id_ir[15:11] == `SRA) 
                    begin
                       //r2未写回
                       if( (ex_ir[15:11] == `ADD || ex_ir[15:11] == `LDIH || ex_ir[15:11] == `ADDI || ex_ir[15:11] == `SUB
                          || ex_ir[15:11] == `SUBI || ex_ir[15:11] == `ADDC || ex_ir[15:11] == `SUBC || ex_ir[15:11] == `AND 
                          || ex_ir[15:11] == `OR || ex_ir[15:11] == `XOR || ex_ir[15:11] == `SLL || ex_ir[15:11] == `SRL
                          || ex_ir[15:11] == `SLA || ex_ir[15:11] == `SRA )&& ex_ir[10:8] == id_ir[6:4])
                            reg_A <= ALUo;
                        else if( (mem_ir[15:11] == `ADD || mem_ir[15:11] == `LDIH || mem_ir[15:11] == `ADDI 
                              || mem_ir[15:11] == `SUB || mem_ir[15:11] == `SUBI || mem_ir[15:11] == `ADDC 
                               || mem_ir[15:11] == `SUBC || mem_ir[15:11] == `AND || mem_ir[15:11] == `OR || mem_ir[15:11] == `XOR 
                               || mem_ir[15:11] == `SLL || mem_ir[15:11] == `SRL || mem_ir[15:11] == `SLA || mem_ir[15:11] == `SRA 
                               || mem_ir[15:11] == `LOAD)&& mem_ir[10:8] == id_ir[6:4])
                                 if(mem_ir[15:11]==`LOAD)
                              reg_A <= d_datain;
                           else
                                    reg_A <= reg_C;
                        else if( (wb_ir[15:11] == `ADD || wb_ir[15:11] == `LDIH || wb_ir[15:11] == `ADDI || wb_ir[15:11] == `SUB
                            || wb_ir[15:11] == `SUBI || wb_ir[15:11] == `ADDC || wb_ir[15:11] == `SUBC || wb_ir[15:11] == `AND 
                            || wb_ir[15:11] == `OR || wb_ir[15:11] == `XOR || wb_ir[15:11] == `SLL || wb_ir[15:11] == `SRL
                            || wb_ir[15:11] == `SLA || wb_ir[15:11] == `SRA || wb_ir[15:11] == `LOAD )&& wb_ir[10:8] == id_ir[6:4])
                             reg_A <= reg_C1;
                        else
                            reg_A <= gr[id_ir[6:4]];//gr2
                     end    
                //flush  
               else if((mem_ir[15:11]==`BZ && zf==1'b1) ||(mem_ir[15:11]==`BNZ && zf==1'b0) 
                  ||(mem_ir[15:11]==`BN && nf==1'b1) || (mem_ir[15:11]==`BNN && nf==1'b0) ||(mem_ir[15:11]==`BC && cin==1'b1)
                ||(mem_ir[15:11]==`BNC && cin==1'b0) || mem_ir[15:11]==`JMPR)
                    reg_A <= 16'bx;  
                else if(id_ir[15:11] == `JUMP)
                    reg_A <= 16'bx;
                else
                    reg_A <= gr[id_ir[6:4]];//gr2
                //regB
                if (id_ir[15:11] == `LOAD || id_ir[15:11] == `STORE || id_ir[15:11] == `SLL || (id_ir[15:11] == `SRL) 
                  || (id_ir[15:11] == `SLA) || (id_ir[15:11] == `SRA))
                    reg_B <= {12'b0000_0000_0000, id_ir[3:0]};//val3
                else if ((id_ir[15:11] == `BZ) || (id_ir[15:11] == `BNZ) || (id_ir[15:11] == `BN) || (id_ir[15:11] == `BNN)
                      || (id_ir[15:11] == `BC) || (id_ir[15:11] == `BNC)
                      || (id_ir[15:11] == `ADDI) || (id_ir[15:11] == `SUBI) || (id_ir[15:11] == `JMPR))
                    reg_B <= {8'b0000_0000, id_ir[7:0]};//{00000000, value2，value3}
                else if(id_ir[15:11] == `LDIH)
                   reg_B <= {id_ir[7:0], 8'b0000_0000};//{val2,val3,00000000)
                //r1=r2#r3
                else if(id_ir[15:11] == `ADD || id_ir[15:11] == `SUB || id_ir[15:11] == `ADDC || id_ir[15:11] == `SUBC 
                    || id_ir[15:11] == `CMP || id_ir[15:11] == `AND || id_ir[15:11] == `OR || id_ir[15:11] == `XOR)
                   begin
                       if( (ex_ir[15:11] == `ADD || ex_ir[15:11] == `LDIH || ex_ir[15:11] == `ADDI || ex_ir[15:11] == `SUB
                          || ex_ir[15:11] == `SUBI || ex_ir[15:11] == `ADDC || ex_ir[15:11] == `SUBC || ex_ir[15:11] == `AND 
                          || ex_ir[15:11] == `OR || ex_ir[15:11] == `XOR || ex_ir[15:11] == `SLL || ex_ir[15:11] == `SRL
                          || ex_ir[15:11] == `SLA || ex_ir[15:11] == `SRA )&& ex_ir[10:8] == id_ir[2:0])
                            reg_B <= ALUo;
                        else if( (mem_ir[15:11] == `ADD || mem_ir[15:11] == `LDIH || mem_ir[15:11] == `ADDI 
                           || mem_ir[15:11] == `LOAD || mem_ir[15:11] == `SUB || mem_ir[15:11] == `SUBI || mem_ir[15:11] == `ADDC 
                            || mem_ir[15:11] == `SUBC || mem_ir[15:11] == `AND || mem_ir[15:11] == `OR || mem_ir[15:11] == `XOR
                            || mem_ir[15:11] == `SLL || mem_ir[15:11] == `SRL || mem_ir[15:11] == `SLA || mem_ir[15:11] == `SRA )
                            && mem_ir[10:8] == id_ir[2:0])
                      begin
                           if(mem_ir[15:11]==`LOAD)
                               reg_B <= d_datain;
                           else
                               reg_B <= reg_C;
                      end
                        else if( (wb_ir[15:11] == `ADD || wb_ir[15:11] == `LDIH || wb_ir[15:11] == `ADDI || wb_ir[15:11] == `SUB
                           || wb_ir[15:11] == `SUBI || wb_ir[15:11] == `ADDC || wb_ir[15:11] == `SUBC || wb_ir[15:11] == `AND 
                           || wb_ir[15:11] == `OR || wb_ir[15:11] == `XOR || wb_ir[15:11] == `SLL || wb_ir[15:11] == `SRL
                           || wb_ir[15:11] == `SLA || wb_ir[15:11] == `SRA || wb_ir[15:11] == `LOAD)&& wb_ir[10:8] == id_ir[2:0])
                             reg_B <= reg_C1;
                        else
                            reg_B <= gr[id_ir[2:0]];//gr2
                     end
                //flush
                else if((mem_ir[15:11]==`BZ && zf==1'b1) ||(mem_ir[15:11]==`BNZ && zf==1'b0) 
                  ||(mem_ir[15:11]==`BN && nf==1'b1) || (mem_ir[15:11]==`BNN && nf==1'b0) ||(mem_ir[15:11]==`BC && cin==1'b1)
                ||(mem_ir[15:11]==`BNC && cin==1'b0) || mem_ir[15:11]==`JMPR)
                    reg_B <= 16'bx; 
                else if(id_ir[15:11] == `JUMP)
                   reg_B <= 16'bx;
                else
                    reg_B <= gr[id_ir[2:0]];//gr3
               //STORE  
               if (id_ir[15:11] == `STORE)
                   begin
                      //r1未写回
                      if(id_ir[10:8] == ex_ir[10:8] && (ex_ir[15:11] == `ADD || ex_ir[15:11] == `LDIH || ex_ir[15:11] == `ADDI 
                         || ex_ir[15:11] == `SUB || ex_ir[15:11] == `SUBI || ex_ir[15:11] == `ADDC || ex_ir[15:11] == `SUBC 
                         || ex_ir[15:11] == `AND || ex_ir[15:11] == `OR || ex_ir[15:11] == `XOR || ex_ir[15:11] == `SLL 
                         || ex_ir[15:11] == `SRL || ex_ir[15:11] == `SLA || ex_ir[15:11] == `SRA ))
                           smdr <= ALUo;
                      else if(id_ir[10:8] == mem_ir[10:8] && (mem_ir[15:11] == `ADD || mem_ir[15:11] == `LDIH 
                         || mem_ir[15:11] == `ADDI || mem_ir[15:11] == `SUB || mem_ir[15:11] == `SUBI || mem_ir[15:11] == `ADDC 
                          || mem_ir[15:11] == `SUBC || mem_ir[15:11] == `AND || mem_ir[15:11] == `OR || mem_ir[15:11] == `XOR
                          || mem_ir[15:11] == `SLL || mem_ir[15:11] == `SRL || mem_ir[15:11] == `SLA || mem_ir[15:11] == `SRA
                          || mem_ir[15:11] == `LOAD))
                           begin
                          if(mem_ir[15:11]==`LOAD)
                              smdr <= d_datain;
                          else
                              smdr <= reg_C;                  
                     end
                      else if(id_ir[10:8] == wb_ir[10:8] && (wb_ir[15:11] == `ADD || wb_ir[15:11] == `LDIH 
                         || wb_ir[15:11] == `LOAD || wb_ir[15:11] == `ADDI || wb_ir[15:11] == `SUB || wb_ir[15:11] == `SUBI 
                          || wb_ir[15:11] == `ADDC || wb_ir[15:11] == `SUBC || wb_ir[15:11] == `AND || wb_ir[15:11] == `OR 
                          || wb_ir[15:11] == `XOR || wb_ir[15:11] == `SLL || wb_ir[15:11] == `SRL || wb_ir[15:11] == `SLA 
                          || wb_ir[15:11] == `SRA ))
                           smdr <= reg_C1;
                      else
                          smdr <= gr[id_ir[10:8]];
                    end
                else
                    smdr <= gr[id_ir[10:8]];


            end
   end
//************* ALU *************//计算
reg signed [15:0] reg_A1;// for SRA 算术右移
always @(*)
begin
  reg_A1 <= reg_A;
end

always @(*)
    begin
      //加减
      if(ex_ir[15:11] == `ADD || ex_ir[15:11] == `LDIH || ex_ir[15:11] == `ADDI) 
         {cf, ALUo} <= reg_A + reg_B;
      else if(ex_ir[15:11] == `CMP || (ex_ir[15:11] == `SUB) || (ex_ir[15:11] == `SUBI))
         {cf, ALUo} <= reg_A - reg_B;
      else if(ex_ir[15:11] == `ADDC)
         {cf, ALUo} <= reg_A + reg_B + cin;
      else if(ex_ir[15:11] == `SUBC)
         {cf, ALUo} <= reg_A - reg_B - cin;
      //逻辑
     else if(ex_ir[15:11] == `AND)
        {cf, ALUo} <= reg_A & reg_B;      
      else if(ex_ir[15:11] == `OR)
         {cf, ALUo} <= reg_A | reg_B;
      else if(ex_ir[15:11] == `XOR)
         {cf, ALUo} <= reg_A ^ reg_B;
      //移位
      else if(ex_ir[15:11] == `SLL)
         {cf, ALUo} <= reg_A << reg_B;
      else if(ex_ir[15:11] == `SRL)
         {cf, ALUo} <= reg_A >> reg_B;
      else if(ex_ir[15:11] == `SLA)
         {cf, ALUo} <= reg_A <<< reg_B;
      else if(ex_ir[15:11] == `SRA)
         {cf, ALUo} <= reg_A1 >>> reg_B;
      //存取、跳转
      else if(ex_ir[15:11] == `LOAD || ex_ir[15:11] == `STORE 
             || ex_ir[15:11] == `BN || ex_ir[15:11] == `BNN || ex_ir[15:11] == `BZ || ex_ir[15:11] == `BNZ
                || ex_ir[15:11] == `BC || ex_ir[15:11] == `BNC || ex_ir[15:11] == `JMPR)
          {cf, ALUo} <= reg_A + reg_B;
      else 
         {cf, ALUo} <= 17'b0;
    end     
//************* EX *************//  执行
always @(posedge clock or negedge reset)
    begin
        if (!reset)
            begin
                mem_ir <= 16'b0000_0000_0000_0000;
                reg_C <= 16'b0000_0000_0000_0000;
                smdr1 <= 16'b0000_0000_0000_0000;
                zf <= 1'b0;
                nf <= 1'b0;
                cin <= 1'b0;
                dw <= 1'b0;
            end 
       else if (state == `exec)
            begin
                mem_ir <= ex_ir;
                reg_C <= ALUo;

                if ((ex_ir[15:11] == `ADD) || (ex_ir[15:11] == `CMP) || (ex_ir[15:11] == `LDIH) || (ex_ir[15:11] == `ADDI) 
                 || (ex_ir[15:11] == `ADDC) || (ex_ir[15:11] == `SUB) || (ex_ir[15:11] == `SUBI) || (ex_ir[15:11] == `SUBC))
                    begin
                        if (ALUo == 16'b0000_0000_0000_0000)
                            zf <= 1'b1;//if zero
                        else
                            zf <= 1'b0;
                        if (ALUo[15] == 1'b1)//if negative 
                            nf <= 1'b1;
                        else
                            nf <= 1'b0;
                    end
                else
                  begin
                     zf <= zf;
                      nf <= nf;
                  end
                //carry 
                if ((ex_ir[15:11] == `ADD) || (ex_ir[15:11] == `LDIH) || (ex_ir[15:11] == `ADDI) || (ex_ir[15:11] == `ADDC)
                 || (ex_ir[15:11] == `SUB) || (ex_ir[15:11] == `SUBI) || (ex_ir[15:11] == `SUBC))                   
                      cin <= cf;
                else
                      cin <= cin; 
                //STORE   
                if (ex_ir[15:11] == `STORE)
                    begin
                        dw <= 1'b1;//data wire enable
                        smdr1 <= smdr;
                    end
                else
                   begin
                       dw <= 1'b0;
                        smdr1 <= 16'b0;
                    end

            end
   end    
//************* MEM *************// 存储器访问
always @(posedge clock or negedge reset)
    begin
        if (!reset)
            begin
                wb_ir <= 16'b0000_0000_0000_0000;
                reg_C1 <= 16'b0000_0000_0000_0000;
            end 
        else if (state == `exec)
            begin
                wb_ir <= mem_ir;
                if (mem_ir[15:11] == `LOAD)
                        reg_C1 <= d_datain;
                else
                        reg_C1 <= reg_C;
            end
   end      
//************* WB *************//
always @(posedge clock or negedge reset)//写回
    begin
        if (!reset)
            begin
                gr[7] <= 16'b0000_0000_0000_0000;
                gr[6] <= 16'b0000_0000_0000_0000;
                gr[5] <= 16'b0000_0000_0000_0000;
                gr[4] <= 16'b0000_0000_0000_0000;
                gr[3] <= 16'b0000_0000_0000_0000;
                gr[2] <= 16'b0000_0000_0000_0000;
                gr[1] <= 16'b0000_0000_0000_0000;
                gr[0] <= 16'b0000_0000_0000_0000;
            end 
        else if (state == `exec)
            begin
                if ((wb_ir[15:11] == `LOAD) || (wb_ir[15:11] == `ADD) || (wb_ir[15:11] == `LDIH) || (wb_ir[15:11] == `ADDI)
                 || (wb_ir[15:11] == `ADDC) || (wb_ir[15:11] == `SUB) || (wb_ir[15:11] == `SUBI) || (wb_ir[15:11] == `SUBC)
                 ||(wb_ir[15:11] == `AND) ||(wb_ir[15:11] == `OR) ||(wb_ir[15:11] == `XOR) || (wb_ir[15:11] == `SLL)
                 ||(wb_ir[15:11] == `SRL) ||(wb_ir[15:11] == `SLA) || (wb_ir[15:11] == `SRA))
                    gr[wb_ir[10:8]] <= reg_C1;//write back to gr1
                else
                   gr[wb_ir[10:8]] <= gr[wb_ir[10:8]];
            end
   end      

endmodule

测试

Instruction Memory： I_mem.v

`include "headfile.v"
module I_mem(input wire [7:0] addra, output reg [15:0] douta
    );
reg [15:0] i_mem[255:0];
always @(*)
   begin
        douta <= i_mem[addra];
    end

initial begin

 //init test
       /*
        i_mem[0]={`ADDI,`gr7,4'd1,4'd0};              // gr7 <= 16'h0010 for store address
        i_mem[1]={`LDIH,`gr1,4'b1011,4'b0110};        // test for LDIH  gr1<="16'hb600"
        i_mem[2]={`STORE,`gr1,1'b0,`gr7,4'h0};        // store to mem10 
        i_mem[3]={`LOAD,`gr1,1'b0,`gr0,4'h0};         // gr1 <= fffd 
        i_mem[4]={`LOAD,`gr2,1'b0,`gr0,4'h1};         // gr2 <= 4
        i_mem[5]={`ADDC,`gr3,1'b0,`gr1,1'b0,`gr2};    // gr3 <= fffd + 4 + cf(=0) = 1, cf<=1
        i_mem[6]={`STORE,`gr3,1'b0,`gr7,4'h1};        // store to mem11     
        i_mem[7]={`ADDC,`gr3,1'b0,`gr0,1'b0,`gr2};    // gr3 <= 0 + 4 + cf(=1) = 5, cf<=0
        i_mem[8]={`STORE,`gr3,1'b0,`gr7,4'h2};        // store to mem12
        i_mem[9]={`LOAD,`gr1,1'b0,`gr0,4'h2};          // gr1 <= 5 
        i_mem[10]={`SUBC,`gr3,1'b0,`gr1,1'b0,`gr2};    // gr3 <= 5 - 4 + cf(=0) =1, cf<=0    
        i_mem[11]={`STORE,`gr3,1'b0,`gr7,4'h3};        // store to mem13        
        i_mem[12]={`SUB,`gr3,1'b0,`gr2,1'b0,`gr1};     // gr3 <= 4 - 5 = -1, cf<=1    
        i_mem[13]={`STORE,`gr3,1'b0,`gr7,4'h4};        // store to mem14        
        i_mem[14]={`SUBC,`gr3,1'b0,`gr2,1'b0,`gr1};    // gr3 <= 5 - 4 - cf(=1) =2, cf<=0 
        i_mem[15]={`STORE,`gr3,1'b0,`gr7,4'h5};        // store to mem15        
        i_mem[16]={`LOAD,`gr1,1'b0,`gr0,4'h3};         // gr1 <= c369
        i_mem[17]={`LOAD,`gr2,1'b0,`gr0,4'h4};         // gr2 <= 69c3       
        i_mem[18]={`AND,`gr3,1'b0,`gr1,1'b0,`gr2};     // gr3 <= gr1 & gr2 = 4141
        i_mem[19]={`STORE,`gr3,1'b0,`gr7,4'h6};        // store to mem16        
        i_mem[20]={`OR,`gr3,1'b0,`gr1,1'b0,`gr2};      // gr3 <= gr1 | gr2 = ebeb
        i_mem[21]={`STORE,`gr3,1'b0,`gr7,4'h7};        // store to mem17        
        i_mem[22]={`XOR,`gr3,1'b0,`gr1,1'b0,`gr2};     // gr3 <= gr1 ^ gr2 = aaaa
        i_mem[23]={`STORE,`gr3,1'b0,`gr7,4'h8};        // store to mem18
        i_mem[24]={`SLL,`gr3,1'b0,`gr1,4'h0};          // gr3 <= gr1 < 0 
        i_mem[25]={`STORE,`gr3,1'b0,`gr7,4'h9};        // store to mem19        
        i_mem[26]={`SLL,`gr3,1'b0,`gr1,4'h1};          // gr3 <= gr1 < 1 
        i_mem[27]={`STORE,`gr3,1'b0,`gr7,4'ha};        // store to mem1a        
        i_mem[28]={`SLL,`gr3,1'b0,`gr1,4'h4};          // gr3 <= gr1 < 8 
        i_mem[29]={`STORE,`gr3,1'b0,`gr7,4'hb};        // store to mem1b    
        i_mem[30]={`SLL,`gr3,1'b0,`gr1,4'hf};          // gr3 <= gr1 < 15 
        i_mem[31]={`STORE,`gr3,1'b0,`gr7,4'hc};        // store to mem1c
        i_mem[32]={`SRL,`gr3,1'b0,`gr1,4'h0};          // gr3 <= gr1 > 0
        i_mem[33]={`STORE,`gr3,1'b0,`gr7,4'hd};        // store to mem1d        
        i_mem[34]={`SRL,`gr3,1'b0,`gr1,4'h1};          // gr3 <= gr1 > 1
        i_mem[35]={`STORE,`gr3,1'b0,`gr7,4'he};        // store to mem1e        
        i_mem[36]={`SRL,`gr3,1'b0,`gr1,4'h8};          // gr3 <= gr1 > 8
        i_mem[37]={`STORE,`gr3,1'b0,`gr7,4'hf};        // store to mem1f        
        i_mem[38]={`SRL,`gr3,1'b0,`gr1,4'hf};          // gr3 <= gr1 > 15
        i_mem[39]={`ADDI,`gr7,4'd1,4'd0};              // gr7 <= 16'h20 for store address
        i_mem[40]={`STORE,`gr3,1'b0,`gr7,4'h0};        // store to mem20
        i_mem[41]={`SLA,`gr3,1'b0,`gr1,4'h0};          // gr3 <= gr1 < 0
        i_mem[42]={`STORE,`gr3,1'b0,`gr7,4'h1};        // store to mem21
        i_mem[43]={`SLA,`gr3,1'b0,`gr1,4'h1};          // gr3 <= gr1 < 1 
        i_mem[44]={`STORE,`gr3,1'b0,`gr7,4'h2};        // store to mem22
        i_mem[45]={`SLA,`gr3,1'b0,`gr1,4'h8};          // gr3 <= gr1 < 8 
        i_mem[46]={`STORE,`gr3,1'b0,`gr7,4'h3};        // store to mem23
        i_mem[47]={`SLA,`gr3,1'b0,`gr1,4'hf};          // gr3 <= gr1 < 15
        i_mem[48]={`STORE,`gr3,1'b0,`gr7,4'h4};        // store to mem24
        i_mem[49]={`SLA,`gr3,1'b0,`gr2,4'h0};          // gr3 <= gr1 < 0
        i_mem[50]={`STORE,`gr3,1'b0,`gr7,4'h5};        // store to mem25
        i_mem[51]={`SLA,`gr3,1'b0,`gr2,4'h1};          // gr3 <= gr1 < 1
        i_mem[52]={`STORE,`gr3,1'b0,`gr7,4'h6};        // store to mem26
        i_mem[53]={`SLA,`gr3,1'b0,`gr2,4'h8};          // gr3 <= gr1 < 8
        i_mem[54]={`STORE,`gr3,1'b0,`gr7,4'h7};        // store to mem27
        i_mem[55]={`SLA,`gr3,1'b0,`gr2,4'hf};          // gr3 <= gr1 < 15
        i_mem[56]={`STORE,`gr3,1'b0,`gr7,4'h8};        // store to mem28
        i_mem[57]={`SRA,`gr3,1'b0,`gr1,4'h0};          // gr3 <= gr1 > 0
        i_mem[58]={`STORE,`gr3,1'b0,`gr7,4'h9};        // store to mem29
        i_mem[59]={`SRA,`gr3,1'b0,`gr1,4'h1};          // gr3 <= gr1 > 1
        i_mem[60]={`STORE,`gr3,1'b0,`gr7,4'ha};        // store to mem2a
        i_mem[61]={`SRA,`gr3,1'b0,`gr1,4'h8};          // gr3 <= gr1 > 8
        i_mem[62]={`STORE,`gr3,1'b0,`gr7,4'hb};        // store to mem2b
        i_mem[63]={`SRA,`gr3,1'b0,`gr1,4'hf};          // gr3 <= gr1 > 15
        i_mem[64]={`STORE,`gr3,1'b0,`gr7,4'hc};        // store to mem2c
        i_mem[65]={`SRA,`gr3,1'b0,`gr2,4'h0};          // gr3 <= gr1 > 0
        i_mem[66]={`STORE,`gr3,1'b0,`gr7,4'hd};        // store to mem2d
        i_mem[67]={`SRA,`gr3,1'b0,`gr2,4'h1};          // gr3 <= gr1 > 1
        i_mem[68]={`STORE,`gr3,1'b0,`gr7,4'he};        // store to mem2e
        i_mem[69]={`SRA,`gr3,1'b0,`gr2,4'h8};          // gr3 <= gr1 > 8
        i_mem[70]={`STORE,`gr3,1'b0,`gr7,4'hf};        // store to mem2f
        i_mem[71]={`ADDI,`gr7,4'd1,4'd0};              // gr7 <= 16'h30 for store address
        i_mem[72]={`SRA,`gr3,1'b0,`gr2,4'hf};          // gr3 <= gr1 > 15
        i_mem[73]={`STORE,`gr3,1'b0,`gr7,4'h0};        // store to mem30        
        i_mem[74]={`LOAD,`gr1,1'b0,`gr0,4'h5};         // gr1 <= 41
        i_mem[75]={`LOAD,`gr2,1'b0,`gr0,4'h6};         // gr2 <= ffff
        i_mem[76]={`LOAD,`gr3,1'b0,`gr0,4'h7};         // gr3 <= 1
        i_mem[77]={`JUMP, 3'd0,8'h4f};                 // jump to 4f
        i_mem[78]={`STORE,`gr7,1'b0,`gr7,4'h1};        // store to mem31
        i_mem[79]={`JMPR, `gr1,8'h10};                 // jump to 41+10 = 51
        i_mem[80]={`STORE,`gr7,1'b0,`gr7,4'h2};        // store to mem32
        i_mem[81]={`ADD, `gr4,1'b0,`gr2,1'b0,`gr3};    // gr4<= ffff + 1,cf<=1
        i_mem[82]={`BNC,`gr1,8'h28};                   // if(cf==0) jump to 69
        i_mem[83]={`BC,`gr1,8'h14};                    // if(cf==1) jump to 55
        i_mem[84]={`STORE,`gr7,1'b0,`gr7,4'h3};        // store to mem33
        i_mem[85]={`ADD, `gr4,1'b0,`gr3,1'b0,`gr3};    // gr4<= 1 + 1 , cf<=0
        i_mem[86]={`BC,`gr1,8'h28};                    // if(cf==1) jump to 69
        i_mem[87]={`BNC,`gr1,8'h18};                   // if(cf==0) jump to 59
        i_mem[88]={`STORE,`gr7,1'b0,`gr7,4'h4};        // store to mem34
        i_mem[89]={`CMP, 3'd0,1'b0,`gr3,1'b0,`gr3};    // 1-1=0 , zf<=1,nf<=0
        i_mem[90]={`BNZ,`gr1,8'h28};                   // if(zf==0) jump to 69
        i_mem[91]={`BZ,`gr1,8'h1c};                    // if(zf==1) jump to 5d
        i_mem[92]={`STORE,`gr7,1'b0,`gr7,4'h5};        // store to mem35
        i_mem[93]={`CMP, 3'd0,1'b0,`gr4,1'b0,`gr3};    // 2-1=1 , zf<=0,nf<=0 
        i_mem[94]={`BZ,`gr1,8'h28};                    // if(zf==1) jump to 69
        i_mem[95]={`BNZ,`gr1,8'h20};                   // if(zf==0) jump to 61
        i_mem[96]={`STORE,`gr7,1'b0,`gr7,4'h6};        // store to mem36
        i_mem[97]={`CMP, 3'd0,1'b0,`gr3,1'b0,`gr4};    // 1-2=-1, nf<=1,zf<=0
        i_mem[98]={`BNN,`gr1,8'h28};                   // if(nf==0) jump to 69
        i_mem[99]={`BN,`gr1,8'h24};                    // if(nf==1) jump to 65 
        i_mem[100]={`STORE,`gr7,1'b0,`gr7,4'h7};       // store to mem37
        i_mem[101]={`CMP, 3'd0,1'b0,`gr4,1'b0,`gr3};   // 2-1=1, nf<=0,zf<=0
        i_mem[102]={`BN,`gr1,8'h28};                   // if(nf==1) jump to 69
        i_mem[103]={`BNN,`gr1,8'h27};                  // if(nf==0) jump to 68
        i_mem[104]={`STORE,`gr7,1'b0,`gr7,4'h8};       // store to mem38
        i_mem[105]={`HALT, 11'd0};                     // STOP*/


    //最大公因数 最小公倍数：gcm

    i_mem[0] <= {`LOAD, `gr1, 1'b0, `gr0, 4'b0001};  //gr1=0009
    i_mem[1] <= {`LOAD, `gr2, 1'b0, `gr0, 4'b0010};  //gr2 = 0003  
    i_mem[2] <= {`ADD, `gr3, 1'b0, `gr0, 1'b0, `gr1}; //gr3=0009  0006  0003
    i_mem[3] <= {`SUB, `gr1, 1'b0, `gr1, 1'b0, `gr2}; //gr1=0006  0003  0
    i_mem[4] <= {`BZ, `gr0, 8'b0000_1001}; //no no jump to 09
    i_mem[5] <= {`BNN, `gr0,  8'b0000_0010}; //jump to 2  jump to 2
    i_mem[6] <= {`ADD, `gr1, 1'b0, `gr0, 1'b0, `gr2};
    i_mem[7] <= {`ADD, `gr2, 1'b0, `gr0, 1'b0, `gr3};
    i_mem[8] <= {`JUMP, 11'b000_0000_0010};
    i_mem[9] <= {`STORE, `gr2, 1'b0, `gr0, 4'b0011}; //d[3]=0003
    i_mem[10] <= {`LOAD, `gr1, 1'b0, `gr0, 4'b0001}; //gr1 = 0009
    i_mem[11] <= {`LOAD, `gr2, 1'b0, `gr0, 4'b0010}; //gr2 = 0003
    i_mem[12] <= {`ADDI, `gr4, 8'h1}; // gr4=1
    i_mem[13] <= {`SUB, `gr2, 1'b0, `gr2, 1'b0, `gr3}; //gr2 = 0
    i_mem[14] <= {`BZ, `gr0, 8'b0001_0000}; //jump to 16
    i_mem[15] <= {`JUMP, 11'b000_0000_1100}; //
    i_mem[16] <= {`SUBI, `gr4, 8'h1}; // gr4 = 0  -1
    i_mem[17] <= {`BN, `gr0, 8'b0001_0100}; //no  jump to 20
    i_mem[18] <= {`ADD, `gr5, 1'b0, `gr5, 1'b0, `gr1};  //gr5 = 0009
    i_mem[19] <= {`JUMP, 11'b000_0001_0000}; //jump to 16
    i_mem[20] <= {`STORE, `gr5, 1'b0, `gr0, 4'b0100}; //d[4]=0009
    i_mem[21] <= {`LOAD, `gr1, 1'b0, `gr0, 4'b0011};//gr1=0003
    i_mem[22] <= {`LOAD, `gr2, 1'b0, `gr0, 4'b0100};//gr2=0009
    i_mem[23] <= {`HALT, 11'b000_0000_0000};


   //64位加法:64badder
    /*
    i_mem[0]=16'h4c04 ; //{`ADDI,`gr4,8'h04};  gr4=0004
   i_mem[1]=16'h1100 ; //{`LOAD, `gr1, 1'b0, `gr0, 4'b0000};  gr1 = fffe
    i_mem[2]=16'h1204 ; //{`LOAD, `gr2, 1'b0, `gr0, 4'b0100};  gr2 = ffff
    i_mem[3]=16'h4312 ; //{`ADD, `gr3, 1'b0, `gr1, 1'b0, `gr2};  gr3 = fffd
    i_mem[4]=16'hfd06 ; //{`BNC, `gr5, 8'b0000_0110};  no
    i_mem[5]=16'h4e01 ; //{`ADDI,`gr6,8'h01};  gr6=0001
    i_mem[6]=16'h4337 ; //{`ADD, `gr3, 1'b0, `gr3, 1'b0, `gr7};  gr3 = fffd
    i_mem[7]=16'hfd0b ; //{`BNC, `gr5, 8'b0000_1011};jump to 11
    i_mem[8]=16'h5e00 ;  //{`SUBI, `gr6, 8'h0}; 
    i_mem[9]=16'hdd0b ;   //{`BNZ, `gr5, 8'h0b};
    i_mem[10]=16'h4e01 ;  //{`ADDI,`gr6,8'h01};
    i_mem[11]=16'h5777 ;    //{`SUB, `gr7, 1'b0, `gr7, 1'b0, `gr7};  gr7 = 0
    i_mem[12]=16'h4776 ;  //{`ADD, `gr7, 1'b0, `gr7, 1'b0, `gr6};  gr7 = 0001
    i_mem[13]=16'h5666 ;    //{`SUB, `gr6, 1'b0, `gr6, 1'b0, `gr6};  gr6 = 0
    i_mem[14]=16'h1b08 ;  //{`STORE, `gr3, 1'b0, `gr0, 4'b1000};  d[8]=fffd
    i_mem[15]=16'h4801 ;     //{`ADDI,`gr0,8'h01};  gr0=0001    
   i_mem[16]=16'h6004 ;  //{`CMP, 3'b0,1'b0,`gr0,1'b0,`gr4}; 1<4
   i_mem[17]=16'he501 ; //{`BN, `gr5, 8'b0000_0001};  jump to 1
    i_mem[18]=16'h0800 ; //halt*/


    //冒泡排序
    /*
    i_mem[0] <= {`LOAD, `gr3, 1'b0, `gr0, 4'b0000};  //gr3=000a;
    i_mem[1] <= {`SUBI, `gr3, 4'd0, 4'd2};   //gr3=0008
    i_mem[2] <= {`ADD, `gr1, 1'b0, `gr0, 1'b0, `gr0};  //gr1=0
    i_mem[3] <= {`ADD, `gr2, 1'b0, `gr3, 1'b0, `gr0}; //gr2=0008
    i_mem[4] <= {`LOAD, `gr4, 1'b0, `gr2, 4'd1}; //gr4=d[9]=1057
    i_mem[5] <= {`LOAD, `gr5, 1'b0, `gr2, 4'd2}; //gr5=d[10]=2895
    i_mem[6] <= {`CMP, 3'd0, 1'b0, `gr5, 1'b0, `gr4}; //d[10] > d[9]
    i_mem[7] <= {`BN, `gr0, 4'b0000, 4'b1010};  //no
    i_mem[8] <= {`STORE, `gr4, 1'b0, `gr2, 4'd2}; //d[10]=gr4
    i_mem[9] <= {`STORE, `gr5, 1'b0, `gr2, 4'd1}; //d[9]=gr5;
    i_mem[10] <= {`SUBI, `gr2, 4'd0, 4'd1};  //gr2=0007
    i_mem[11] <= {`CMP, 3'd0, 1'b0, `gr2, 1'b0, `gr1}; //gr2>gr1
    i_mem[12] <= {`BNN, `gr0, 4'h0, 4'b0100}; //
    i_mem[13] <= {`ADDI, `gr1, 4'd0, 4'd1};
    i_mem[14] <= {`CMP, 3'd0, 1'b0, `gr3, 1'b0, `gr1};
    i_mem[15] <= {`BNN, `gr0, 4'h0, 4'b0011};
    i_mem[16] <= {`HALT, 11'd0};
    */

    //sort
    /*
    i_mem[0] <= {`ADDI, `gr1, 4'b0000,  4'b1001};
    i_mem[1] <= {`ADDI, `gr2, 4'b0000,  4'b1001};
    i_mem[2] <= {`JUMP, 11'b000_0000_0101};//jump to start
    i_mem[3] <= {`SUBI, `gr1, 4'd0, 4'd1};//new_round
    i_mem[4] <= {`BZ, `gr7, 4'b0001, 4'b0010};//jump to end
    i_mem[5] <= {`LOAD, `gr3, 1'b0, `gr0, 4'd0};//start
    i_mem[6] <= {`LOAD, `gr4, 1'b0, `gr0, 4'd1};
    i_mem[7] <= {`CMP, 3'd0, 1'b0, `gr3, 1'b0, `gr4};
    i_mem[8] <= {`BN, `gr7, 4'h0, 4'b1011};//jump to NO_op
    i_mem[9] <= {`STORE, `gr3, 1'b0, `gr0, 4'd1};
    i_mem[10] <= {`STORE, `gr4, 1'b0, `gr0, 4'd0};
    i_mem[11] <= {`ADDI, `gr0, 4'b0000, 4'b0001};//NO_OP
    i_mem[12] <= {`CMP, 3'd0, 1'b0, `gr0, 1'b0, `gr2};
    i_mem[13] <= {`BN, `gr7, 4'b0001, 4'b0001};//jump to continue 
    i_mem[14] <= {`SUBI, `gr2, 4'd0, 4'd1};
    i_mem[15] <= {`SUB, `gr0, 1'b0,`gr0, 1'b0,`gr0};
    i_mem[16] <= {`JUMP, 11'b000_0000_0011};//jump to new round
    i_mem[17] <= {`JUMP, 11'b000_0000_0101};//jump to start,continue
    i_mem[18] <= {`HALT, 11'd0};//end
    */

end

endmodule

Data Memory ： D_mem.v

module D_mem(input wire wea, input wire [7:0] addra, input wire [15:0] dina, output wire [15:0] douta
    );
reg [15:0] d_mem[255:0];

assign  douta = d_mem[addra];

always @(*)
   begin
        if(wea == 1'b1)
             d_mem[addra] <= dina;
   end

initial begin
  //init_test
  /*
  d_mem[0] <= 16'hfffd;
  d_mem[1] <= 16'h0004;
  d_mem[2] <= 16'h0005;
  d_mem[3] <= 16'hc369;
  d_mem[4] <= 16'h69c3;
  d_mem[5] <= 16'h0041;
  d_mem[6] <= 16'hffff;
  d_mem[7] <= 16'h0001;
  d_mem[8] <= 16'h0000;
  d_mem[9] <= 16'h0000;
  d_mem[10] <= 16'h0000;*/

  //最大公因数 最小公倍数data

  d_mem[0] <= 16'h0000;
  d_mem[1] <= 16'h0020;  //32
  d_mem[2] <= 16'h0018;   //24      8 96

  //64badde
  /*
  d_mem[0] <= 16'hfffe;
  d_mem[1] <= 16'hfffe;
  d_mem[2] <= 16'hfffe;
  d_mem[3] <= 16'h0000;
  d_mem[4] <= 16'hffff;
  d_mem[5] <= 16'hffff;
  d_mem[6] <= 16'hffff;
  d_mem[7] <= 16'h0000;
  */
  //冒泡排序
  /*
  d_mem[0] <= 16'h000a;
  d_mem[1] <= 16'h0004;
  d_mem[2] <= 16'h0005;
  d_mem[3] <= 16'h2369;
  d_mem[4] <= 16'h69c3;
  d_mem[5] <= 16'h0060;
  d_mem[6] <= 16'h0fff;
  d_mem[7] <= 16'h5555;
  d_mem[8] <= 16'h6152;
  d_mem[9] <= 16'h1057;
  d_mem[10] <= 16'h2895;
  d_mem[11] <= 16'h0000;
  */
    //sort
  /*
  d_mem[0] = 16'h000a;
  d_mem[1] = 16'h0009;
  d_mem[2] = 16'h0006;
  d_mem[3] = 16'h0005;
  d_mem[4] = 16'h0001;
  d_mem[5] = 16'h0004;
  d_mem[6] = 16'h0003;
  d_mem[7] = 16'h0011;
  d_mem[8] = 16'h0000;
  d_mem[9] = 16'h0000;
  d_mem[10] = 16'h0000;
  d_mem[11] = 16'h0000;/
 */
end
endmodule

仿真文件test.v

module test;

    // Inputs
    reg clk;
    reg enable;
    reg reset;
    reg start;

    // Instantiate the Unit Under Test (UUT)
    cpu uut (
        .clk(clk), 
        .enable(enable), 
        .reset(reset), 
        .start(start)
    );
   always #5 clk = ~clk;
    initial begin
        // Initialize Inputs
        clk = 0;
        enable = 0;
        reset = 0;
        start = 0;

      $monitor("%h:%b:%h:%h:%h:%h:%h:%h:%b:%h:%h:%h:%h:%h:%h:%h:%h:%b:%b:%b", 
         uut.pcpu.pc, uut.pcpu.id_ir, uut.pcpu.reg_A, uut.pcpu.reg_B, uut.pcpu.reg_C,
         uut.pcpu.d_addr, uut.pcpu.d_dataout, uut.pcpu.ALUo, uut.pcpu.d_we, uut.pcpu.reg_C1, uut.pcpu.gr[1], uut.pcpu.gr[2], uut.pcpu.gr[3],
          uut.pcpu.gr[4], uut.pcpu.gr[5], uut.pcpu.gr[6],
          uut.pcpu.gr[7], uut.pcpu.cin, uut.pcpu.nf, uut.pcpu.zf);

        // Wait 100 ns for global reset to finish
        #100;
      $display("pc:      id_ir:    regA:regB:regC:da:dout:ALUo:dwe:reC1: gr1:gr2:gr3: gr4: gr5: gr6: gr7: cf:nf:zf");        
        // Add stimulus here
        #10 reset <= 0;
      #10 reset <= 1;
      #10 enable <= 1;
      #10 start <=1;
        #10 start <= 0;
        #100;   

    end

endmodule

结果验证(Data Memory)

init_test
最大公约数和最小公倍数
数字0x20和数字0x18的最大公约数是 0x0008，最小公倍数是0x0060。
64位加法
冒泡排序
0x000a表示要对10个数字进行排序，下面为十个排好序的数字。
排序

你可能感兴趣的:(数字电路设计)

Quartus网盘资源下载与安装附图文安装教程学习天使Alice fpga开发学习
如大家所了解的，Quartus是一种FPGA设计软件（相信理工科的小伙伴，很多都接触或学习过FPGA），旨在为数字电路设计师提供一个高效、便捷的开发环境。它可以帮助用户完成数字逻辑电路的设计、仿真、综合和布局，以及与外围设备进行通信和控制。Quartus支持多种编程语言，包括VHDL、Verilog等，并具有丰富的功能和工具库，可满足不同级别、不同规模的数字电路设计需求。收藏的Quartus安装包
笔试题-2023-思特威-数字电路设计（CIS）【纯净题目版】 lu-ming.xyz 2023 面试实录面经刷题秋招数字IC设计
回到首页：2023数字IC设计秋招复盘——数十家公司笔试题、面试实录推荐内容：数字IC设计学习比较实用的资料推荐题目背景笔试时间：2022.08.18笔试时长：90min应聘岗位：数字电路设计工程师（CIS）笔试平台：showmebug题目评价难易程度：★★☆☆☆知识覆盖：★☆☆☆☆超纲范围：☆☆☆☆☆值得一刷：★☆☆☆☆文章目录1数字IC设计的流程包含哪些？2简述下D-Latch与D-Flipf
1.【Multisim仿真】数电模电学习，仿真软件的初步使用 m0_61659911 学习
学习计划路径：>Multisim电路仿真软件熟练掌握>数字电路基础课程>逻辑电路设计与应用>熟练掌握存储器、脉冲波形发生器、D/A和A/D转换器原理>基本元器件熟练掌握>晶体管放大电路及负反馈放大电路>集成运算放大器设计>电压变电流电路设计>绝对值电路设计>压力传感器电路设计>STM32最小系统设计一。Multisim仿真初步了解1.主页功能布置二。数字电路设计基础1.正逻辑与负逻辑1.数字信号是
【转载】高速信号关键信号的布线要求山里天空蓝高速设计关键信号时钟接口
关键信号的识别关键信号通常包括以下信号：时钟信号（*CLK*）,复位信号（*rest*,*rst*）,JTAG信号(*TCK*)部分关键信号布线要求汇总一、时钟信号布线要求在数字电路设计中，时钟信号是一种在高态与低态之间振荡的信号，决定着电路的性能。时钟电路在数字电路中点有重要地位，同时又是产生电磁辐射的主要来源。时钟的处理方法也是在PCB布线时需要特别重视的。在一开始就理清时钟树，明确各种时钟之
Multisim14.0仿真（二十九）74LS190计数器应用设计 colin工作室 Multisim仿真嵌入式硬件
一、74LS190简介：74LS190是一种常用的4位同步计数器芯片，可以实现多种计数和控制操作，在数字电路设计和应用中广泛使用。二、74LS190引脚定义：三、74LS190功能表：
竞争与冒险㉨㉨零基础学数字电路模电学习
在数字电路设计中，竞争与冒险是常见的问题，它们可能导致电路输出的不稳定和错误。因此，了解如何消除竞争与冒险是非常重要的。一、竞争与冒险的概念竞争：在数字电路中，多个信号同时改变状态，导致电路无法准确判断输出的情况。冒险：由于信号传输延迟或逻辑门的延迟，导致电路在短时间内产生不正确的输出。二、消除竞争与冒险的方法增加门延迟：通过在逻辑门之间添加延迟元件，如电阻、电容等，可以使信号有足够的时间传播和稳
Modelsim SE 10.5安装教程 GBXLUO FPGA fpga开发 modelsim
ModelSim是一种功能强大的硬件描述语言(HDL，HardwareDescriptionLanguage)仿真和验证工具，可以单独仿真，也可以联合Quartus/Vivado等软件联合仿真，仿真速度快，广泛应用于数字电路设计和验证领域。大学老师爱教VHDL语言，但是进入社会以后，基本都是VerilogHDL语言，简单易学，建议用Verilog来仿真与做FPGA工程。一、资源：Modelsim_
数字电路设计——加法器爱寂寞的时光电子技术计算机体系结构算法硬件工程嵌入式硬件
数字电路设计——加法器半加器半加器只有两个一位宽的输入aaa和bbb，输出a+ba+ba+b所产生的本位和sumsumsum和进位coutcoutcout。组合逻辑为：S=A⊕B,Cout=ABS=A\oplusB,Cout=ABS=A⊕B,Cout=AB真值表和原理图符合为：SystemVerilog实现代码：modulehadder(inputlogica,inputlogicb,output
数字电路设计——流水线处理器爱寂寞的时光硬件工程嵌入式硬件
数字电路设计——流水线处理器从内存或是寄存器组读写、操作ALU是处理器中最耗时的操作。我们将一个指令拆成五个流水线阶段，每个阶段同时执行耗时的组合逻辑。这五个阶段分别是取指令、解码、执行、访存和写回。在取指令阶段，处理器从指令存储器中读取一条指令。在解码阶段，处理器从寄存器组读取两个操作数，并解码指令产生相应的控制信号。在执行阶段，处理器执行ALU命令。在访存阶段，处理器从内存中读取数据或者是写入
Verilog实现FPGA平均值计算 uote_e fpga开发 matlab
Verilog实现FPGA平均值计算在数字电路设计中，计算平均值是一个非常基础的操作。本文将通过Verilog语言来实现在FPGA中计算一个数据流的平均值。首先，我们需要定义一个计数器和一个累加器来分别记录输入数据流的总数和总和。这里我们使用32位的寄存器作为计数器和累加器，并将它们都初始化为零。reg[31:0]count=0;reg[31:0]sum=0;然后，在每个时钟周期内，我们需要读取输
在电路实际设计中PCI 的三态和 OD、OC 信号要有上拉。手搓机械电路设计嵌入式硬件
在PCI总线以及其他数字电路设计中，三态（Tri-state）、开漏（OpenDrain,OD）和开集（OpenCollector,OC）是常见的输出信号类型。这些信号类型通常需要外部上拉电阻来确保信号线在不被任何设备驱动时能够被拉到高电平状态。三态（Tri-state）信号，三态信号具有高电平、低电平和高阻态（Hi-Z）三种状态。高阻态是指输出驱动器断开连接，使得信号线既不被拉高也不被拉低。在P
简易加减运算器的制作----数字电路设计（含proteus仿真）江江江江江江江江江 proteus 单片机 stm32
简易加减运算器的制作一、功能要求—基本功能1、自制0-9按键，在一个LED数码管上稳定地显示当前按下的值。（基本功能）2、增加+、=两个按键，实现0-9两个一位数的加法运算，同时在两位LED上稳定地显示运算结果。（扩展功能1）3、再增加一个-按钮，实现0-9两个一位数的减法运算，同时在两位LED上稳定地显示运算结果。（扩展功能2）功能一实现对于在LED数码管上显示数字最合适的就是74hc48。74
几种基本门电路有关符号&内容&汇总 O&REO 笔记本硬件架构 c语言集成测试
逻辑常量：只有两个(0和1)，表示两个对立的逻辑状态。逻辑变量：逻辑变量一般用字母、数字及其组合来表示，其取值只有两个，即0和1。在“正逻辑”的数字电路设计中，用低电平信号（如0.5V）表示逻辑0；用高电平信号（如3V）表示逻辑1。逻辑运算：对于逻辑常量和变量的操作，有与、或、非三种基本逻辑运算。逻辑门（logicgates）：对逻辑常量和变量完成基本的逻辑运算的电路。在数字电路中，表示逻辑变量之
verilog语法基础-移位寄存器 q511951451 fpga开发 verilog基本语法移位寄存器数据延迟链
概述：移位寄存器在数字电路设计中广泛被使用，列如SPI通讯中的串行输入并行输出，并行输出串行输出，FIR滤波器中作为数据的延迟链，边沿检测中的数据延迟链等等。本节针对移位寄存器的基本应用场景给出基本的模版，并观测FPGA综合后的结构图。内容：1.一位分立移位寄存器2.串行输入，并行输出延迟链3.循环移位寄存器4.并行输入串行输出延迟链5.总线并行延迟链1.一位分立移位寄存器代码moduleregt
【FPGA】数字电路设计基础无损检测小白白 fpga开发
数字电路基础1什么是数字电路在学习数字电路之前，我们先要了解下什么是数字电路。想要搞明白数字电路，就要搞明白生活中有两种概念，数字信号和模拟信号，模拟信号一般包括压力、气温、速度等信号，模拟量的值是可能随时间连续变化的。而数字量，是指从时间上变化都不是连续的信号，比如电平信号。下图分别是模拟信号和数字信号的示意图。在IC/FPGA逻辑设计里面，一般只能处理数字信号，当然，现在有一些高端的FPGA，
做嵌入式硬件工程师最重要的是什么嵌入式开发小七嵌入式硬件 fpga开发
做嵌入式硬件工程师最重要的是什么呢？做嵌入式工程师不仅需要扎实的理论基础还得需要丰厚的经验，具备那种大型的、高频CPU、多层PCB板的设计经验。要熟悉模拟电路设计、数字电路设计、电磁波理论等。熟悉常用的放大电路、滤波电路、电源电路设计和分析这些课程，需要掌握基础技能有：故障定位、解决问题的能力;设计文档的组织编写技能；熟练运用单片机、DSP、PLD、FPGA等进行软硬件开发调试的能力；熟练运用设计
FPGA UCF约束文件全解老董1 笔记
（一）约束的分类：利用FPGA进行系统设计常用的约束主要分为3类。（1）时序约束：主要用于规范设计的时序行为，表达设计者期望满足的时序条件，知道综合和布局布线阶段的优化算法等。（2）布局布线约束：主要用于指定芯片I/O引脚位置以及指导软件在芯片特定的物理区域进行布局布线。（3）其它约束：指目标芯片型号、接口位置、电气特性等约束属性。（二）约束的主要作用（1）提高设计的工作效率对很多数字电路设计来说
【华为内部资料】《高速数字电路设计教材》（可下载）移知 IC 学习集成电路华为
与数字技术或软件相比，模拟技术人才的培养和造就仍然需要一定的实践和时间，但无论数字技术发展到任何阶段将永远离不开模拟技术。由于难度系数较大的原因，有时即便投入很多精力，如果缺乏耐心、毅力和必要的条件，投入也并非一定有回报，但一旦在一定程度上掌握了模拟应用技术，那么在未来的职业生涯中并将具有“杀手锏”一样的竞争力。为了学习这些必要的模拟技术，老师的指导是必不可少的，但是在现实中不见得谁都能够找到最合
Verilog 学习笔记悟OO道 fpga开发 Verilog
VerilogHDL的基本语法模块•VerilogHDL程序是由模块构成的。每个模块的内容都是嵌在module和endmodule两个语句之间。每个模块实现特定的功能。模块是可以进行层次嵌套的。正因为如此,才可以将大型的数字电路设计分割成不同的小模块来实现特定的功能,最后通过顶层模块调用子模块来实现整体功能。•每个模块要进行端口定义,并说明输入输出口,然后对模块的功能进行行为逻辑描述。•Veril
STM32串口DMA双缓冲，数据接收与发送，HAL库实现小李干净又卫生 STM32 stm32 单片机嵌入式硬件
STM32串口DMA双缓冲1.简介STM32F429系列DMA支持双缓冲模式进行数据传输，相当于数字电路设计领域的乒乓操作，但是HAL库并没有实现像单缓冲区一样可以简单使用的函数，有的方法是使用单缓冲的方式，但是通过接收半满的中断控制CPU进行数据处理，相当于是把一个缓冲区拆成两半使用。双缓冲的优势是显而易见的，在将串口数据写入到一个缓冲区时，CPU同时可以进行另一个缓冲区的读取，可以加快数据的处
零基础入门Python基础知识全面梳理！从零开始成为编程高手 python零基础入门小白 python 开发语言程序人生学习深度学习经验分享
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录一、python程序的组成二、核心的数字类型1.整型int（0、负自然数、正自然数）2.浮点数float（带有小数部分的数，小数部分可为0，表示精度不一样）3.复数complex（分为实部real和虚部image，虚部必须以j或者J结尾）4.布尔类型bool（用来表达真/假俩种状态的类型，符合计算机数字电路设计）三、表达式和运
笔试题-2023-加特兰-数字IC设计【纯净题目版】 lu-ming.xyz 2023 面试实录数字IC 经验分享刷题笔试题秋招
回到首页：2023数字IC设计秋招复盘——数十家公司笔试题、面试实录推荐内容：数字IC设计学习比较实用的资料推荐题目背景笔试时间：2022.07.27应聘岗位：数字电路设计工程师（SoC)-2023届笔试时长：90min笔试平台：nowcoder牛客网题目类型：问答题（11道）主观评价难易程度：★★★☆☆知识覆盖：★★★☆☆超纲范围：☆☆☆☆☆值得一刷：★★★★☆文章目录1WhatdoestheH
基于数字电路交通灯信号灯控制系统设计-基于单片机病房温度监测与呼叫系统设计-基于STM32的无线蓝牙心电监护仪系统设计-基于STM32的智能蓝牙温控风扇控制设计-基于STM32的智能温室控制系统设计 BINGHANYULENG stm32 嵌入式硬件 51单片机单片机 c语言
1617基于数字电路交通灯信号灯控制系统设计（仿真电路，论文报告）摘要：交通灯控制系统在城市交通控制中发挥着重要的作用，本次课程设计就是以城市交通灯控制系统为背景的，主要通过运用学过的数字电路设计的知识完成基础的交通灯基本功能，包括时间的定时和交通灯各种状态之间的转换，并且要实现通行和禁行的时间的设置，本次设计采用数字电路仿真软件Proteus对所设计的电路进行仿真和测试，并通过观察仿真结果看设计
基于数字电路交通灯信号灯控制系统设计-单片机设计 01单片机设计单片机 1024程序员节
**单片机设计介绍，1617基于数字电路交通灯信号灯控制系统设计（仿真电路，论文报告文章目录一概要二、功能设计设计思路三、软件设计原理图五、程序文档六、文章目录一概要交通灯控制系统在城市交通控制中发挥着重要的作用，本次课程设计就是以城市交通灯控制系统为背景的，主要通过运用学过的数字电路设计的知识完成基础的交通灯基本功能，包括时间的定时和交通灯各种状态之间的转换，并且要实现通行和禁行的时间的设置
解决proteus仿真时出现的错误 Cannot open 'C:\User\***\AppDate\Local\Temp\LISA4832.SDF' 代码小学生&
学习单片机和数字电路设计都要用到Proteus仿真软件对电路图进行模拟仿真，这时候如果你的电脑用户名含中文字符就会报如下错误。1.Cannotopen‘C:\User\XXX\AppDate\Local\Temp\LISA4832.SDF’2.SimulationFAILEDduetofatalsimulatorerrors.解决方法方法一:更改账户名称通过将现有的账户名称改为英文名，最重要的是一
数字电路设计得力助手——《Design Compiler User Guide》移知 IC 学习
在当今数字化时代，电子设备和芯片的需求日益增长，这使得数字电路设计变得愈发重要。在数字电路设计过程中，使用先进的工具和技术是至关重要的。Synopsys公司的DesignCompiler®就是这样一款备受推崇的设计编译器软件，而其详尽的用户指南——《DesignCompiler®UserGuide》则是数字电路设计领域的一本宝典。解锁数字电路设计的奥秘DesignCompiler能够将高级硬件描述
FPGA设计入门：Vivado综合简介追逐程序梦想者 fpga开发 matlab
FPGA设计入门：Vivado综合简介FPGA是一种基于可编程逻辑器件的数字电路设计技术，可以通过编程实现各种电路功能。Vivado是Xilinx公司推出的一款开发工具，可以用来对FPGA进行综合、布局、布线、生成比特流等操作。本篇文章将从Vivado综合的基本流程入手，详细介绍如何使用Vivado对FPGA进行综合。一、综合的基本流程在Vivado中，综合是将RTL(硬件描述语言)代码转换成网表
2019-08-19 这个女人又在思考了
标题：向华为学习？OPPO也要造手机芯片啦！近期，筹备良久的OPPO手机芯片业务终于开始启动。报道称，“OPPO的招聘信息，非常明确地传达出手机芯片的信号。”一位资深猎头向记者介绍，“比如，SoC设计工程师这个职位，要求能够完成SoC架构定义、功能设计和子系统级别的架构设计，熟悉ARM系列CPU芯片，熟练使用EDA，有的还要求28nm以下设计经验。还有芯片数字电路设计工程师、芯片验证工程师、芯片前
FPGA病房呼叫系统实现 QQ_778132974 D1：verilog设计 fpga开发
数字电路设计题目：病房呼叫系统的FPGA实现。实现了题目要求：支持呼叫记忆功能，有呼叫优先级，护士值班室可给予病房呼叫响应信号。使用verilog语言在QuartusII下实现文工程没有调用IP核，都是自己设计的代码文件，可以用于ISE，vivado等开发工具下使用下面是工程顶层模块代码部分截图：顶层模块代码：moduleSRCall(clk,rst_n,rea_1_n,sin_8_n,reque
verilog 写rtl注意事项_Verilog RTL代码风格介绍五莲花开 verilog 写rtl注意事项
1使用标准的DFF模块例化生成寄存器寄存器是数字同步电路中最基本的单元。使用Verilog进行数字电路设计时，最常见的方式是使用always块语法生成寄存器，要点如下：对于寄存器避免直接使用always块编写，而是应该采用模块化的标准DFF模块进行例化。示例如下所示，一个名为flg_dfflr的寄存器，除了时钟(clk)和复位信号(rst_n)之外，还带有使能信号flg_ena和输入(flg_nx
Spring的注解积累 yijiesuifeng spring 注解
用注解来向Spring容器注册Bean。需要在applicationContext.xml中注册： <context:component-scan base-package=”pagkage1[,pagkage2,…,pagkageN]”/>。如：在base-package指明一个包 <context:component-sc
传感器百合不是茶 android 传感器
android传感器的作用主要就是来获取数据,根据得到的数据来触发某种事件下面就以重力传感器为例; 1,在onCreate中获得传感器服务 private SensorManager sm;// 获得系统的服务 private Sensor sensor;// 创建传感器实例 @Override protected void
[光磁与探测]金吕玉衣的意义 comsci
这是一个古代人的秘密:现在告诉大家信不信由你们: 穿上金律玉衣的人,如果处于灵魂出窍的状态,可以飞到宇宙中去看星星这就是为什么古代
精简的反序打印某个数沐刃青蛟打印
以前看到一些让求反序打印某个数的程序。比如：输入123，输出321。记得以前是告诉你是几位数的，当时就抓耳挠腮，完全没有思路。似乎最后是用到%和/方法解决的。而今突然想到一个简短的方法，就可以实现任意位数的反序打印（但是如果是首位数或者尾位数为0时就没有打印出来了）代码如下： long num, num1=0;
PHP：6种方法获取文件的扩展名 IT独行者 PHP 扩展名
PHP：6种方法获取文件的扩展名 1、字符串查找和截取的方法 1 $extension = substr ( strrchr ( $file , '.' ), 1); 2、字符串查找和截取的方法二 1 $extension = substr
面试111 文强chu 面试
1事务隔离级别有那些，事务特性是什么（问到一次） 2 spring aop 如何管理事务的，如何实现的。动态代理如何实现，jdk怎么实现动态代理的，ioc是怎么实现的，spring是单例还是多例，有那些初始化bean的方式，各有什么区别（经常问） 3 struts默认提供了那些拦截器（一次） 4 过滤器和拦截器的区别（频率也挺高） 5 final，finally final
XML的四种解析方式小桔子 dom jdom dom4j sax
在平时工作中，难免会遇到把 XML 作为数据存储格式。面对目前种类繁多的解决方案，哪个最适合我们呢？在这篇文章中，我对这四种主流方案做一个不完全评测，仅仅针对遍历 XML 这块来测试，因为遍历 XML 是工作中使用最多的（至少我认为）。　　预备　　测试环境：　　AMD 毒龙1.4G OC 1.5G、256M DDR333、Windows2000 Server
wordpress中常见的操作 aichenglong 中文注册 wordpress 移除菜单
1 wordpress中使用中文名注册解决办法 1)使用插件 2)修改wp源代码进入到wp-include/formatting.php文件中找到 function sanitize_user( $username, $strict = false
小飞飞学管理-1 alafqq 管理
项目管理的下午题，其实就在提出问题（挑刺），分析问题，解决问题。今天我随意看下10年上半年的第一题。主要就是项目经理的提拨和培养。结合我自己经历写下心得对于公司选拔和培养项目经理的制度有什么毛病呢？ 1，公司考察，选拔项目经理，只关注技术能力，而很少或没有关注管理方面的经验，能力。 2，公司对项目经理缺乏必要的项目管理知识和技能方面的培训。 3，公司对项目经理的工作缺乏进行指
IO输入输出部分探讨百合不是茶 IO
//文件处理在处理文件输入输出时要引入java.IO这个包； /* 1，运用File类对文件目录和属性进行操作 2，理解流，理解输入输出流的概念 3，使用字节/符流对文件进行读/写操作 4，了解标准的I/O 5，了解对象序列化 */ //1，运用File类对文件目录和属性进行操作 //在工程中线创建一个text.txt
getElementById的用法 bijian1013 element
getElementById是通过Id来设置/返回HTML标签的属性及调用其事件与方法。用这个方法基本上可以控制页面所有标签，条件很简单，就是给每个标签分配一个ID号。返回具有指定ID属性值的第一个对象的一个引用。语法： &n
励志经典语录 bijian1013 励志人生
经典语录1: 哈佛有一个著名的理论：人的差别在于业余时间，而一个人的命运决定于晚上8点到10点之间。每晚抽出2个小时的时间用来阅读、进修、思考或参加有意的演讲、讨论，你会发现，你的人生正在发生改变，坚持数年之后，成功会向你招手。不要每天抱着QQ/MSN/游戏/电影/肥皂剧……奋斗到12点都舍不得休息，看就看一些励志的影视或者文章，不要当作消遣；学会思考人生，学会感悟人生
[MongoDB学习笔记三]MongoDB分片 bit1129 mongodb
MongoDB的副本集(Replica Set)一方面解决了数据的备份和数据的可靠性问题，另一方面也提升了数据的读写性能。MongoDB分片(Sharding)则解决了数据的扩容问题，MongoDB作为云计算时代的分布式数据库，大容量数据存储，高效并发的数据存取，自动容错等是MongoDB的关键指标。本篇介绍MongoDB的切片(Sharding) 1.何时需要分片 &nbs
【Spark八十三】BlockManager在Spark中的使用场景 bit1129 manager
1. Broadcast变量的存储，在HttpBroadcast类中可以知道 2. RDD通过CacheManager存储RDD中的数据，CacheManager也是通过BlockManager进行存储的 3. ShuffleMapTask得到的结果数据，是通过FileShuffleBlockManager进行管理的，而FileShuffleBlockManager最终也是使用BlockMan
yum方式部署zabbix ronin47 yum方式部署zabbix
安装网络yum库#rpm -ivh http://repo.zabbix.com/zabbix/2.4/rhel/6/x86_64/zabbix-release-2.4-1.el6.noarch.rpm 通过yum装mysql和zabbix调用的插件还有agent代理#yum install zabbix-server-mysql zabbix-web-mysql mysql-
Hibernate4和MySQL5.5自动创建表失败问题解决方法 byalias J2EE Hibernate4
今天初学Hibernate4，了解了使用Hibernate的过程。大体分为4个步骤： ①创建hibernate.cfg.xml文件 ②创建持久化对象 ③创建*.hbm.xml映射文件 ④编写hibernate相应代码在第四步中，进行了单元测试，测试预期结果是hibernate自动帮助在数据库中创建数据表，结果JUnit单元测试没有问题，在控制台打印了创建数据表的SQL语句，但在数据库中
Netty源码学习-FrameDecoder bylijinnan java netty
Netty 3.x的user guide里FrameDecoder的例子，有几个疑问： 1.文档说：FrameDecoder calls decode method with an internally maintained cumulative buffer whenever new data is received. 为什么每次有新数据到达时，都会调用decode方法？ 2.Dec
SQL行列转换方法 chicony 行列转换
create table tb(终端名称 varchar(10) , CEI分值 varchar(10) , 终端数量 int) insert into tb values('三星' , '0-5' , 74) insert into tb values('三星' , '10-15' , 83) insert into tb values('苹果' , '0-5' , 93)
中文编码测试 ctrain 编码
循环打印转换编码 String[] codes = { "iso-8859-1", "utf-8", "gbk", "unicode" }; for (int i = 0; i < codes.length; i++) { for (int j
hive 客户端查询报堆内存溢出解决方法 daizj hive 堆内存溢出
hive> select * from t_test where ds=20150323 limit 2; OK Exception in thread "main" java.lang.OutOfMemoryError: Java heap space 问题原因： hive堆内存默认为256M 这个问题的解决方法为：修改/us
人有多大懒，才有多大闲 (评论『卓有成效的程序员』) dcj3sjt126com 程序员
卓有成效的程序员给我的震撼很大，程序员作为特殊的群体，有的人可以这么懒，懒到事情都交给机器去做，而有的人又可以那么勤奋，每天都孜孜不倦得做着重复单调的工作。在看这本书之前，我属于勤奋的人，而看完这本书以后，我要努力变成懒惰的人。不要在去庞大的开始菜单里面一项一项搜索自己的应用程序，也不要在自己的桌面上放置眼花缭乱的快捷图标
Eclipse简单有用的配置 dcj3sjt126com eclipse
1、显示行号 Window -- Prefences -- General -- Editors -- Text Editors -- show line numbers 2、代码提示字符 Window ->Perferences，并依次展开 Java -> Editor -> Content Assist，最下面一栏 auto-Activation
在tomcat上面安装solr4.8.0全过程 eksliang Solr solr4.0后的版本安装 solr4.8.0安装
转载请出自出处： http://eksliang.iteye.com/blog/2096478 首先solr是一个基于java的web的应用，所以安装solr之前必须先安装JDK和tomcat，我这里就先省略安装tomcat和jdk了第一步：当然是下载去官网上下载最新的solr版本，下载地址
Android APP通用型拒绝服务、漏洞分析报告 gg163 漏洞 android APP 分析
点评：记得曾经有段时间很多SRC平台被刷了大量APP本地拒绝服务漏洞，移动安全团队爱内测（ineice.com）发现了一个安卓客户端的通用型拒绝服务漏洞，来看看他们的详细分析吧。 0xr0ot和Xbalien交流所有可能导致应用拒绝服务的异常类型时，发现了一处通用的本地拒绝服务漏洞。该通用型本地拒绝服务可以造成大面积的app拒绝服务。针对序列化对象而出现的拒绝服务主要
HoverTree项目已经实现分层 hvt 编程 .net Web C#ASP.ENT
HoverTree项目已经初步实现分层，源代码已经上传到 http://hovertree.codeplex.com请到SOURCE CODE查看。在本地用SQL Server 2008 数据库测试成功。数据库和表请参考：http://keleyi.com/a/bjae/ue6stb42.htmHoverTree是一个ASP.NET 开源项目，希望对你学习ASP.NET或者C#语言有帮助，如果你对
Google Maps API v3: Remove Markers 移除标记天梯梦 google maps api
Simply do the following: I. Declare a global variable: var markersArray = []; II. Define a function: function clearOverlays() { for (var i = 0; i < markersArray.length; i++ )
jQuery选择器总结 lq38366 jquery 选择器
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
基础数据结构和算法六：Quick sort sunwinner Algorithm Quicksort
Quick sort is probably used more widely than any other. It is popular because it is not difficult to implement, works well for a variety of different kinds of input data, and is substantially faster t
如何让Flash不遮挡HTML div元素的技巧_HTML/Xhtml_网页制作刘星宇 html Web
今天在写一个flash广告代码的时候，因为flash自带的链接，容易被当成弹出广告，所以做了一个div层放到flash上面，这样链接都是a触发的不会被拦截，但发现flash一直处于div层上面，原来flash需要加个参数才可以。让flash置于DIV层之下的方法，让flash不挡住飘浮层或下拉菜单，让Flash不档住浮动对象或层的关键参数：wmode=opaque。方法如下：
Mybatis实用Mapper SQL汇总示例 wdmcygah sql mysql mybatis 实用
Mybatis作为一个非常好用的持久层框架，相关资料真的是少得可怜，所幸的是官方文档还算详细。本博文主要列举一些个人感觉比较常用的场景及相应的Mapper SQL写法，希望能够对大家有所帮助。不少持久层框架对动态SQL的支持不足，在SQL需要动态拼接时非常苦恼，而Mybatis很好地解决了这个问题，算是框架的一大亮点。对于常见的场景，例如：批量插入/更新/删除，模糊查询，多条件查询，联表查询，