Subversion Repositories qrisc32

//////////////////////////////////////////////////////////////////////////////////////////////

//    Project Qrisc32 is risc cpu implementation, purpose is studying

//    Digital System Design course at Kyoung Hee University during my PhD earning

//    Copyright (C) 2010  Vinogradov Viacheslav

//

//    This library is free software; you can redistribute it and/or

//   modify it under the terms of the GNU Lesser General Public

//    License as published by the Free Software Foundation; either

//    version 2.1 of the License, or (at your option) any later version.

//

//    This library is distributed in the hope that it will be useful,

//    but WITHOUT ANY WARRANTY; without even the implied warranty of

//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

//    Lesser General Public License for more details.

//

//    You should have received a copy of the GNU Lesser General Public

//    License along with this library; if not, write to the Free Software

//    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

//

//

//////////////////////////////////////////////////////////////////////////////////////////////

`timescale 1ns / 1ns

module qrisc32_tb;

//Parameters declaration:

        import risc_pack::*;

        //Internal signals declarations:

        bit reset,clk;

        //I data

        logic[31:0]     idata;

        logic[31:0]     iaddr;

        logic           ird;

        logic           ireq;

        //D read

        logic[31:0]     rdata;

        logic[31:0]     raddr;

        logic           rrd;

        logic           rreq=0;

        //D write

        logic[31:0]     wdata;

        logic[31:0]     waddr;

        logic           wwr;

        logic           wreq=0;

        logic           Istop_active,Dstop_active;

        bit                     Istop_enable,Dstop_enable;

        bit                     verbose;

        //emulates Instruction ram

        mem             Iram(

                .clk(clk),

                .add_r(iaddr),

                .add_w(32'h0),

                .data_w(32'h0),

                .rd(ird),

                .wr(1'b0),

                .data_r(idata),

                .req(ireq),

                .stop_enable(Istop_enable),

                .stop_active(Istop_active),

                .verbose(verbose)

        );

        defparam Iram.size=256;

        defparam Iram.adr_limit=93;

        //emulates Data ram

        mem             Dram(

                .clk(clk),

                .add_r(raddr),

                .add_w(waddr),

                .data_w(wdata),

                .rd(rrd),

                .wr(wwr),

                .data_r(rdata),

                .req(),

                .stop_enable(Dstop_enable),

                .stop_active(Dstop_active),

                .verbose(verbose)

        );

        defparam Dram.size=10;

        defparam Dram.adr_limit=10;

        // Unit Under Test port map

        qrisc32 UUT(

                .reset(reset),

                .clk(clk),

                //avalon master port only for  reading instructions

                .avm_instructions_data(idata),

                .avm_instructions_addr(iaddr),

                .avm_instructions_rd(ird),

                .avm_instructions_wait_req(ireq),

                //avalon master port only for  reading data

                .avm_datar_data(rdata),

                .avm_datar_addr(raddr),

                .avm_datar_rd(rrd),

                .avm_datar_wait_req(rreq),

                //avalon master port only for  writing data

                .avm_dataw_data(wdata),

                .avm_dataw_addr(waddr),

                .avm_dataw_wr(wwr),

                .avm_dataw_wait_req(wreq),

                .verbose(verbose)

        );

        int address;

        bit signed[14:0] jmpr_label0,jmpr_label1;

        bit [25:0] ilabel,jlabel,inclabel,jmp_label1;

        function        void loadIram;

                input[31:0]     data;

                begin

                        Iram.sram[address] = data;

                        address=address+1;

                end

        endfunction

        task    load_buble_sort;

        /*buble algorithm

                R0=mem[00],R1=mem[04],R2=mem[08],R3=mem[c],R4=mem[10]

                R5=mem[14],R6=mem[18],R7=mem[1c],R8=mem[20],R9=mem[24]

                R10=R0;

                R11=R0;//minimum

                if R1

                        R11=R1

                if R2

                        R11=R2

                if R3

                        R11=R3

                if R4

                        R11=R4

                if R5

                        R11=R5

                if R6

                        R11=R6

                if R7

                        R11=R7

                if R8

                        R11=R8

                if R9

                        R11=R9

                mem[0]=R11;

                for (i = 36; i > 0; i-=4)//36,32,28,24,20,16,12,8,4

                {

                        if R0>R10

                                R10=R0

                        if R1>R10

                                R10=R1

                        if R2>R10

                                R10=R2

                        if R3>R10

                                R10=R3

                        if R4>R10

                                R10=R4

                        if R5>R10

                                R10=R5

                        if R6>R10

                                R10=R6

                        if R7>R10

                                R10=R7

                        if R8>R10

                                R10=R8

                        if R9>R10

                                R10=R9

                        mem[i]=R10;

                        //substitute maximum by minimum

                        if R10=R0

                                R0=R11

                        if R10=R1

                                R1=R11

                        if R10=R2

                                R2=R11

                        if R10=R3

                                R3=R11

                        if R10=R4

                                R4=R11

                        if R10=R5

                                R5=R11

                        if R10=R6

                                R6=R11

                        if R10=R7

                                R7=R11

                        if R10=R8

                                R8=R11

                        if R10=R9

                                R9=R11

                }*/

        //loading instructions

                address=0;

                //verbose=1;

                //Istop_enable=1;

                loadIram({LDRH,16'h0000,R12});//R12 is 36

                loadIram({XOR,DECR_0,7'h0,R13,R13,R13});//R13 is 0

                loadIram({LDRH,16'hFFFF,R14});//R14 is -4

                loadIram({LDRL,16'h0024,R12});//R12 is 36

                loadIram({LDRP,OFFSET_CODE,15'd00,R13,R0});//ldr R0,[R13+0]

                loadIram({LDRP,OFFSET_CODE,15'd04,R13,R1});//ldr R1,[R13+4]

                loadIram({LDRP,OFFSET_CODE,15'd08,R13,R2});//ldr R2,[R13+8]

                loadIram({LDRP,OFFSET_CODE,15'd12,R13,R3});//ldr R3,[R13+12]

                loadIram({LDRP,OFFSET_CODE,15'd16,R13,R4});//ldr R4,[R13+16]

                loadIram({LDRP,OFFSET_CODE,15'd20,R13,R5});//ldr R5,[R13+20]

                loadIram({LDRP,OFFSET_CODE,15'd24,R13,R6});//ldr R6,[R13+24]

                loadIram({LDRP,OFFSET_CODE,15'd28,R13,R7});//ldr R7,[R13+28]

                loadIram({LDRP,OFFSET_CODE,15'd32,R13,R8});//ldr R8,[R13+32]

                loadIram({LDRP,OFFSET_CODE,15'd36,R13,R9});//ldr R9,[R13+36]

                loadIram({LDRL,-16'd4,R14});//R14 is -4

                //search for minimum

                loadIram({CMP,INCR_0,7'h0,R0,R1,R1});

                loadIram({LDRC,INCR_0,7'h0,R0,R1,R16});

                loadIram({CMP,INCR_0,7'h0,R3,R2,R2});

                loadIram({LDRC,INCR_0,7'h0,R3,R2,R17});

                loadIram({CMP,INCR_0,7'h0,R5,R4,R4});

                loadIram({LDRC,INCR_0,7'h0,R5,R4,R18});

                loadIram({CMP,INCR_0,7'h0,R7,R6,R6});

                loadIram({LDRC,INCR_0,7'h0,R7,R6,R19});

                loadIram({CMP,INCR_0,7'h0,R9,R8,R8});

                loadIram({LDRC,INCR_0,7'h0,R9,R8,R20});

                loadIram({CMP,INCR_0,7'h0,R17,R16,R16});

                loadIram({LDRC,INCR_0,7'h0,R17,R16,R21});

                loadIram({CMP,INCR_0,7'h0,R19,R18,R18});

                loadIram({LDRC,INCR_0,7'h0,R19,R18,R22});

                loadIram({CMP,INCR_0,7'h0,R21,R20,R20});

                loadIram({LDRC,INCR_0,7'h0,R21,R20,R23});

                loadIram({NOP});

                loadIram({CMP,INCR_0,7'h0,R23,R22,R22});

                loadIram({LDRC,INCR_0,7'h0,R23,R22,R11});

                loadIram({NOP});

                //minimum write

                loadIram({STRP,OFFSET_CODE,15'd0,R13,R11});//str R10,[R13+0]

                //

                //search for maximum

                loadIram({CMP,INCR_0,7'h0,R0,R1,R1});

                loadIram({LDRNC,INCR_0,7'h0,R0,R1,R16});

                loadIram({CMP,INCR_0,7'h0,R3,R2,R2});

                jmpr_label0=4*address;

                loadIram({LDRNC,INCR_0,7'h0,R3,R2,R17});

                loadIram({CMP,INCR_0,7'h0,R5,R4,R4});

                loadIram({LDRNC,INCR_0,7'h0,R5,R4,R18});

                loadIram({CMP,INCR_0,7'h0,R7,R6,R6});

                loadIram({LDRNC,INCR_0,7'h0,R7,R6,R19});

                loadIram({CMP,INCR_0,7'h0,R9,R8,R8});

                loadIram({LDRNC,INCR_0,7'h0,R9,R8,R20});

                loadIram({CMP,INCR_0,7'h0,R17,R16,R16});

                loadIram({LDRNC,INCR_0,7'h0,R17,R16,R21});

                loadIram({CMP,INCR_0,7'h0,R19,R18,R18});

                loadIram({LDRNC,INCR_0,7'h0,R19,R18,R22});

                loadIram({CMP,INCR_0,7'h0,R21,R20,R20});

                loadIram({LDRNC,INCR_0,7'h0,R21,R20,R23});

                loadIram({NOP});

                loadIram({CMP,INCR_0,7'h0,R23,R22,R22});

                loadIram({LDRNC,INCR_0,7'h0,R23,R22,R10});

                loadIram({NOP});

                loadIram({STRP,OFFSET_CODE,15'd0,R12,R10});//str R10,[R12+0]

                loadIram({ADD,DECR_0,7'h0,R14,R12,R12});//R12 = R12 + R12( -4)

                loadIram({CMP,INCR_0,7'h0,R0,R10,R10});

                loadIram({LDRZ,INCR_0,7'h0,R0,R11,R0});

                loadIram({CMP,INCR_0,7'h0,R1,R10,R10});

                loadIram({LDRZ,INCR_0,7'h0,R1,R11,R1});

                loadIram({CMP,INCR_0,7'h0,R2,R10,R10});

                loadIram({LDRZ,INCR_0,7'h0,R2,R11,R2});

                loadIram({CMP,INCR_0,7'h0,R3,R10,R10});

                loadIram({LDRZ,INCR_0,7'h0,R3,R11,R3});

                loadIram({CMP,INCR_0,7'h0,R4,R10,R10});

                loadIram({LDRZ,INCR_0,7'h0,R4,R11,R4});

                loadIram({CMP,INCR_0,7'h0,R5,R10,R10});

                loadIram({LDRZ,INCR_0,7'h0,R5,R11,R5});

                loadIram({CMP,INCR_0,7'h0,R6,R10,R10});

                loadIram({LDRZ,INCR_0,7'h0,R6,R11,R6});

                loadIram({CMP,INCR_0,7'h0,R7,R10,R10});

                loadIram({LDRZ,INCR_0,7'h0,R7,R11,R7});

                loadIram({CMP,INCR_0,7'h0,R8,R10,R10});

                loadIram({LDRZ,INCR_0,7'h0,R8,R11,R8});

                loadIram({CMP,INCR_0,7'h0,R9,R10,R10});

                loadIram({LDRZ,INCR_0,7'h0,R9,R11,R9});

                loadIram({CMP,INCR_0,7'h0,R13,R12,R12});//cmp R12 with R13(0)

                jmpr_label1=jmpr_label0-4*address-8;

                loadIram({JMPNZ,OFFSET_CODE,jmpr_label1,10'h0});

                loadIram({LDRR,DECR_0,7'h0,R11,R11,R10});//R10 =R11

                loadIram({CMP,INCR_0,7'h0,R0,R1,R1});

                loadIram({LDRNC,INCR_0,7'h0,R0,R1,R16});

                loadIram({CMP,INCR_0,7'h0,R3,R2,R2});

        endtask;

        task    load_shell_sort_mdf;

        /*new algorithm

                for(inc = 20;inc>0;inc=inc/2)//20, 8 and 4 (5,2,1)

                {

                        for (i = inc; i < 40; i+=4)//0..4..8..c and etc

                        {

                                temp = a[i];

                                for (j = i; (j >= inc) && (a[j-inc] > temp); j =j-inc)

                                {

                                        a[j] = a[j-inc];

                                }

                        a[j] = temp;

                        }

                }*/

        //---------------------  reverse(709) random(714) sorted(516)

        //loading instructions

                address=0;

                loadIram({LDRH,16'h0000,R5});//R5 inc = 5

                loadIram({LDRH,16'h0000,R8});//R8 =1

                loadIram({LDRH,16'h0000,R9});//R9 =2

                loadIram({LDRH,16'h0000,R10});//R10 is 4

                loadIram({LDRH,16'h0000,R12});//R12 is 40

                loadIram({LDRH,16'hFFFF,R13});//R13 is mask 0xffff_ffff

                loadIram({LDRH,16'h0000,R14});//R14 is 3

                loadIram({LDRL,16'h0005,R5});//R5 inc = 5

                loadIram({LDRL,16'h0001,R8});//R8 =1

                loadIram({LDRL,16'h0002,R9});//R9 =2

                loadIram({LDRL,16'h0004,R10});//R10 is 4

                loadIram({LDRL,16'h0028,R12});//R12 is 40

                loadIram({LDRL,16'hFFFF,R13});//R13 is mask 0xffff_ffff

                loadIram({LDRL,16'h0003,R14});//R14 is 3

                //R5 - inc

                //R6 - -inc

                //R7 - j-inc

                //R4 - i

                //R3 - J

                //for (inc...

                inclabel = 4*address;

                jmpr_label0 = 4*address;

                loadIram({SHL,INCR_0,7'h0,R9,R5,R5});//R5 = R5<

                jmpr_label1=1000*4;//out of code

                loadIram({JMPZ,OFFSET_CODE,jmpr_label1,10'h0});//R5>0?

                loadIram({XOR,DECR_0,7'h0,R13,R5,R6});//R6 = R5 xor R13

                loadIram({LDRR,DECR_0,7'h0,R5,R5,R4});//i(R4)=inc (R5)

                loadIram({ADD,DECR_0,7'h0,R8,R6,R6});//R6 = R6 + R8( +1)

                loadIram({SHR,INCR_0,7'h0,R14,R5,R5});//R5 = R5>>R14( R5>>3))

                loadIram({CMP,INCR_0,7'h0,R12,R4,R4});//compare R4 with R12(i == 40) if 0 then reached maximum-> stop

                ilabel=4*address;

                jmpr_label1=jmpr_label0-4*address-8;

                loadIram({JMPZ,OFFSET_CODE,jmpr_label1,10'h0});//if =40 then goto inc

                //temp  - r1

                loadIram({LDRP,OFFSET_CODE,15'd0,R4,R1});//ldr R1,[R4]

                //for (j = i;..

                loadIram({LDRR,DECR_0,7'h0,R4,R4,R3});//j(R3)=i(R4)

                loadIram({ADD,DECR_0,7'h0,R4,R6,R7});//R7 = R4+R6=(i)j-inc

                loadIram({CMP,INCR_0,7'h0,R5,R3,R3});//cmp R3 j with R5 inc

                jlabel=4*address;

                //a[j-inc]  - r0

                loadIram({LDRP,OFFSET_CODE,15'd0,R7,R0});//ldrp R0,[R7]

                jmpr_label1=13*4;

                loadIram({JMPC,OFFSET_CODE,jmpr_label1,10'h0});//c=1 then R3 j < R5 inc

                loadIram({NOP});loadIram({NOP});loadIram({NOP});

                //a[j-inc] > temp?

                loadIram({CMP,INCR_0,7'h0,R1,R0,R0});//cmp R0 a[j-inc] with R1 temp

                jmpr_label1=8*4;

                loadIram({JMPC,OFFSET_CODE,jmpr_label1,10'h0});//c=1 then R0>R1

                loadIram({NOP});loadIram({NOP});loadIram({NOP});loadIram({NOP});

                loadIram({JMP,jlabel});//goto next cycle of J

                loadIram({LDRR,DECR_0,7'h0,R7,R7,R3});//j=j-inc,  R3=R7

                //a[j] = a[j-inc];

                loadIram({STRP,OFFSET_CODE,15'd0,R3,R0});//str R0,[R3+0]

                loadIram({ADD,DECR_0,7'h0,R3,R6,R7});//R7 = R3+R6=j-inc

                loadIram({CMP,INCR_0,7'h0,R5,R3,R3});//cmp R3 j with R5 inc

                //

                loadIram({JMP,ilabel});//goto next cycle of i

                loadIram({ADD,DECR_0,7'h0,R10,R4,R4});//R4=R4+R10...i+=4

                //a[j] = temp;

                loadIram({STRP,OFFSET_CODE,15'd0,R3,R1});//str R3,[R7+0]

                loadIram({CMP,INCR_0,7'h0,R12,R4,R4});//compare R4 with R12(i == 40) if 0 then reached maximum-> stop

                loadIram({NOP});

        endtask;

        task    shell_first;

        //old

        // for (i = 0; i < 36; i+=4) {

        // temp = a[i+4];

        // for (j = i; (j >= 0) && (a[j] > temp); j -= 4)a[j+4] = a[j];

        // a[j+4] = temp;

        //loading instructions

                address=0;

                loadIram({LDRH,16'h0000,R10});//R10 is 4

                loadIram({LDRH,16'hffff,R11});//R11 is -4

                loadIram({LDRH,16'h0000,R12});//R12 is 36

                jmp_label1 = 4*address+4*8;

                loadIram({JMP,jmp_label1});//goto entry point

                loadIram({XOR,INCR_0,7'h0,R4,R4,R4});//i base of data

                loadIram({LDRL,16'h0004,R10});//R10 is 4

                loadIram({LDRL,16'hFFFC,R11});//R11 is -4

                loadIram({LDRL,16'h0024,R12});//R12 is 36

                //R4  is i=0 base of data

                //R7  is J

                //end of main cycle

                jmpr_label0=4*address;

                jmpr_label1=4*address+32*8;

                loadIram({JMPZ,OFFSET_CODE,jmpr_label1,10'h0});//goto to out of main cycle

                loadIram({LDRR,DECR_0,7'h0,R5,R4,R7});//R7 = R4   ->R7 is J

                //a[j+4] = temp;

                loadIram({STRP,OFFSET_CODE,15'd4,R7,R0});//str R0,[R7+4]

                //main cycle here (I)-------------------------------------------------

                //entry point

                //temp=a[i],  R0 is temp

                loadIram({LDRP,OFFSET_CODE,15'd0,R4,R15});//ldr R0,[R4+0]

                //check j <0

                loadIram({XOR,DECR_0,7'h0,R7,R11,R2});//compare R7 with -4

                loadIram({LDRP,OFFSET_CODE,15'd4,R4,R0});//ldr R0,[R4+4]

                //

                jmp_label1=4*address;

                jmpr_label1=jmpr_label0-4*address-8;

                loadIram({JMPZ,OFFSET_CODE,jmpr_label1,10'h0});//Z=1 when J<0 goto end of main cycle a[j+4] = temp;

                //i+=4

                loadIram({ADD,DECR_0,7'h0,R10,R4,R4});//R4 = R4+4

                loadIram({LDRR,DECR_0,7'h0,R15,R15,R1});//R1=R15

                //check i =36?

                loadIram({XOR,INCR_0,7'h0,R12,R4,R2});//R2=R4^R12(i xor 36) if 0 then reached maximum-> stop

                //a[j] read

                loadIram({LDRP,OFFSET_CODE,-15'd4,R7,R15});//ldr R15,[R7-4]

                //compare R1(a[j]) with R0(temp)

                loadIram({CMP,INCR_0,7'h0,R0,R1,R2});

                jmpr_label1=jmpr_label0-4*address-8;

                loadIram({JMPC,OFFSET_CODE,jmpr_label1,10'h0});//c=1 then R1<=R0   - (a[j] > temp) is false goto end of subcycle (A[j+4]=temp)

                loadIram({NOP});loadIram({NOP});loadIram({NOP});

                //check i =36?

                loadIram({XOR,INCR_0,7'h0,R12,R4,R2});//R2=R4^R12(i xor 36) if 0 then reached maximum-> stop

                loadIram({JMP,jmp_label1});//goto subcycle

                //j-=4

                loadIram({ADD,DECR_0,7'h0,R7,R11,R7});//R7 = R7-4

                //i-=4

                loadIram({ADD,DECR_0,7'h0,R11,R4,R4});//R4 = R4-4

                //a[j+4] = a[j](R1);

                loadIram({STRP,OFFSET_CODE,15'd8,R7,R1});//str R1,[R7+4]                A[j+4]=temp

                loadIram({XOR,DECR_0,7'h0,R7,R11,R2});//compare R7 with -4

        endtask;

        task    load_unsorted_data(bit[1:0] kind);

        //loading  unsorted data in Dram

                for(int i=0;i<10;i++)

                        Dram.sram[i]=(kind==0)? 10-i:                   //reverse unsorted

                                                (kind==1)?      100+$random%100://randomly unsorted

                                                                        i+1;                    //already sorted

        endtask;

        task    start;

                reset=1;

                $display("Programm size is %d Words",address);

                #100;

                reset=0;

                #1us;

                @(posedge       Istop_active);

                $display("Sort finished");

                $display("Cycles for sorting -->%0d<--",cycles);

        endtask;

        initial

        begin

                Istop_enable=0;

                Dstop_enable=0;

                verbose=0;

                for(int i=0;i<3;i++)

                begin

                        $display("------------------Start round %d------------------",i);

                        load_unsorted_data(i);

                        $display("Load buble sort...");

                        load_buble_sort;

                        start;

                        load_unsorted_data(i);

                        $display("Load shell modified...");

                        load_shell_sort_mdf;

                        start;

                        load_unsorted_data(i);

                        $display("Load shell first...");

                        shell_first;

                        start;

                end

                $finish;

        end

        initial

        begin

                clk=0;

                forever #10 clk<=!clk;

        end

        int cycles;

        always@(posedge clk or posedge reset)

        if(reset)

                cycles=0;

        else

                cycles=cycles+1;

endmodule