URL https://opencores.org/ocsvn/an-fpga-implementation-of-low-latency-noc-based-mpsoc/an-fpga-implementation-of-low-latency-noc-based-mpsoc/trunk

Subversion Repositories an-fpga-implementation-of-low-latency-noc-based-mpsoc

[/] [an-fpga-implementation-of-low-latency-noc-based-mpsoc/] [trunk/] [mpsoc/] [rtl/] [src_modelsim/] [traffic_pattern.sv] - Blame information for rev 48

Go to most recent revision | Details | Compare with Previous | View Log


/**************************************
* Module: traffic_pattern
* Date:2015-10-05
* Author: alireza
*
* Description:
***************************************/
 
`timescale  1ns/1ps
 
 
 
/************************************
 
        pck_class_in_gen
 
***********************************/
 
module pck_class_in_gen #(
    parameter C = 4,    //  number of packet class
    parameter C0_p = 25,    //  the percentage of injected packets with class 0
    parameter C1_p = 25,
    parameter C2_p = 25,
    parameter C3_p = 25
)(
    pck_class_o,
    en,
    reset,
    clk
 
);
 
    function integer log2;
      input integer number; begin
         log2=(number <=1) ? 1: 0;
         while(2**log2
            log2=log2+1;
         end
      end
    endfunction // log2
 
 
    localparam
    Cw = (C>1)? log2(C) : 1,
    RNDw = log2(100);
 
    output reg [Cw-1    :   0]  pck_class_o;
    input                       reset,clk,en;
    reg       [RNDw-1  :   0]  rnd;
 
 
 
 // generate a random num between 0 to 99
    always @(posedge clk ) begin
        if(en | reset) begin
                rnd =     $urandom_range(99,0);
        end
    end
 
    always @(*) begin
        if      ( rnd <   C0_p)                 pck_class_o =0;
        else if ( rnd <   (C0_p+C1_p))          pck_class_o =1;
        else if ( rnd <   (C0_p+C1_p+C2_p))     pck_class_o =2;
        else                                    pck_class_o =3;
    end
 
 
 
endmodule
 
/**********************************
 
        pck_dst_gen
 
*********************************/
 
 
module  pck_dst_gen
        import pronoc_pkg::*;
        #(
    parameter NE=4,
    parameter TRAFFIC =   "RANDOM",
    parameter MAX_PCK_NUM = 10000,
    parameter HOTSPOT_NODE_NUM =  4
)(
    en,
    current_e_addr,
    core_num,
    pck_number,
    dest_e_addr,
    clk,
    reset,
    valid_dst,
    hotspot_info,
        custom_traffic_t,
        custom_traffic_en
);
 
 
    localparam      ADDR_DIMENSION =   (TOPOLOGY ==    "MESH" || TOPOLOGY ==  "TORUS") ? 2 : 1;  // "RING" and FULLY_CONNECT
 
 
    function integer log2;
      input integer number; begin
         log2=(number <=1) ? 1: 0;
         while(2**log2
            log2=log2+1;
         end
      end
    endfunction // log2
 
 
    localparam  NEw= log2(NE),
                PCK_CNTw = log2(MAX_PCK_NUM+1),
                HOTSPOT_NUM= (TRAFFIC=="HOTSPOT")? HOTSPOT_NODE_NUM : 1;
 
    input                       reset,clk,en;
    input   [NEw-1      :   0]  core_num;
    input   [PCK_CNTw-1 :   0]  pck_number;
    input   [EAw-1      :   0]  current_e_addr;
    output  [EAw-1      :   0]  dest_e_addr;
    output                      valid_dst;
        input  [NEw-1 : 0] custom_traffic_t;
        input  custom_traffic_en;
 
    input hotspot_t  hotspot_info [HOTSPOT_NUM-1 : 0];
 
 
     generate
     if ( ADDR_DIMENSION == 2) begin :two_dim
 
        two_dimension_pck_dst_gen #(
                .NE(NE),
                .TRAFFIC(TRAFFIC),
                .MAX_PCK_NUM(MAX_PCK_NUM),
                .HOTSPOT_NODE_NUM(HOTSPOT_NODE_NUM)
 
        )
        the_two_dimension_pck_dst_gen
        (
                .reset(reset),
                .clk(clk),
                .en(en),
                .core_num(core_num),
                .pck_number(pck_number),
                .current_e_addr(current_e_addr),
            .dest_e_addr(dest_e_addr),
                .valid_dst(valid_dst),
                .hotspot_info(hotspot_info),
                        .custom_traffic_t(custom_traffic_t),
                        .custom_traffic_en(custom_traffic_en)
        );
 
     end else begin : one_dim
 
        one_dimension_pck_dst_gen #(
                        .NE(NE),
                        .TRAFFIC(TRAFFIC),
                        .MAX_PCK_NUM(MAX_PCK_NUM),
                        .HOTSPOT_NODE_NUM(HOTSPOT_NODE_NUM)
        )
        the_one_dimension_pck_dst_gen
        (
            .reset(reset),
            .clk(clk),
            .en(en),
            .core_num(core_num),
            .pck_number(pck_number),
            .current_e_addr(current_e_addr),
            .dest_e_addr(dest_e_addr),
            .valid_dst(valid_dst),
            .hotspot_info(hotspot_info),
                        .custom_traffic_t(custom_traffic_t),
                        .custom_traffic_en(custom_traffic_en)
        );
 
     end
     endgenerate
 endmodule
 
 
 
 
module two_dimension_pck_dst_gen
                import pronoc_pkg::*;
        #(
                parameter NE=4,
                parameter TRAFFIC =   "RANDOM",
                parameter MAX_PCK_NUM = 10000,
                parameter HOTSPOT_NODE_NUM =  4
 
)(
    en,
    current_e_addr,
    dest_e_addr,
    core_num,
    pck_number,
    clk,
    reset,
    valid_dst,
    hotspot_info,
        custom_traffic_t,
        custom_traffic_en
);
 
 
    function integer log2;
      input integer number; begin
         log2=(number <=1) ? 1: 0;
         while(2**log2
            log2=log2+1;
         end
      end
    endfunction // log2
 
 
    localparam NEw= log2(NE),
                PCK_CNTw = log2(MAX_PCK_NUM+1),
                HOTSPOT_NUM= (TRAFFIC=="HOTSPOT")? HOTSPOT_NODE_NUM : 1;
 
    input                       reset,clk,en;
    input   [NEw-1      :   0]  core_num;
    input   [PCK_CNTw-1 :   0]  pck_number;
    input   [EAw-1 : 0] current_e_addr;
    output  [EAw-1 : 0]  dest_e_addr;
    output                      valid_dst;
    input hotspot_t  hotspot_info [HOTSPOT_NUM-1 : 0];
        input  [NEw-1 : 0] custom_traffic_t;
        input  custom_traffic_en;
 
    localparam
        NX = T1,
        NY = T2,
        NL = T3,
        NXw = log2(NX),
        NYw= log2(NY),
        NLw= log2(NL);
 
    wire [NXw-1 : 0] current_x;
    wire [NYw-1 : 0] current_y;
    wire [NLw-1  : 0] current_l;
    wire [NXw-1 : 0] dest_x;
    wire [NYw-1 : 0] dest_y;
    wire [NLw-1  : 0] dest_l;
 
    mesh_tori_endp_addr_decode #(
        .TOPOLOGY(TOPOLOGY),
        .T1(T1),
        .T2(T2),
        .T3(T3),
        .EAw(EAw)
    )
    src_addr_decode
    (
        .e_addr(current_e_addr),
        .ex(current_x),
        .ey(current_y),
        .el(current_l),
        .valid( )
    );
 
    wire off_flag;
 
 
 
 
 
    wire    [NEw-1  :   0]  dest_ip_num;
    genvar i;
 
    generate
    if (TRAFFIC == "RANDOM") begin
 
        logic [6 : 0] rnd_reg;
 
        always @(posedge clk ) begin
                if(en | reset) begin
                        rnd_reg =     $urandom_range(NE-1,0);
                        if(SELF_LOOP_EN == "NO")        while(rnd_reg==core_num) rnd_reg =     $urandom_range(NE-1,0);// get a random IP core, make sure its not same as sender core
 
                end
        end
        assign dest_ip_num = rnd_reg;
 
       endp_addr_encoder #(
        .T1(T1),
        .T2(T2),
        .T3(T3),
        .NE(NE),
        .EAw(EAw),
        .TOPOLOGY(TOPOLOGY)
       )
       addr_encoder
       (
        .id(dest_ip_num),
        .code(dest_e_addr)
       );
 
     end else if (TRAFFIC == "HOTSPOT") begin
 
        hot_spot_dest_gen  #(
                        .HOTSPOT_NUM(HOTSPOT_NUM),
                        .NE(NE),
                        .NEw(NEw)
                )hspot
                (
                        .reset(reset),
                        .clk(clk),
                        .en(en),
                        .hotspot_info(hotspot_info),
                        .dest_ip_num (dest_ip_num),
                        .core_num(core_num),
                        .off_flag(off_flag)
                );
 
        endp_addr_encoder #(
            .T1(T1),
            .T2(T2),
            .T3(T3),
            .NE(NE),
            .EAw(EAw),
            .TOPOLOGY(TOPOLOGY)
        )
        addr_encoder
        (
            .id(dest_ip_num),
            .code(dest_e_addr)
        );
 
 
 
    end else if( TRAFFIC == "TRANSPOSE1") begin
 
        assign dest_x   = NX-current_y-1;
        assign dest_y   = NY-current_x-1;
        assign dest_l   = NL-current_l-1;
        assign dest_e_addr = (T3==1)? {dest_y,dest_x} : {dest_l,dest_y,dest_x};
 
        endp_addr_decoder  #(
                .T1(T1),
                .T2(T2),
                .T3(T3),
                .NE(NE),
                .EAw(EAw),
                .TOPOLOGY(TOPOLOGY)
        )enc
        (
                .code(dest_e_addr),
                .id(dest_ip_num)
        );
 
 
 
 
 
 
    end else if( TRAFFIC == "TRANSPOSE2") begin :transpose2
 
        assign dest_x   = current_y;
        assign dest_y   = current_x;
        assign dest_l   = current_l;
        assign dest_e_addr = (T3==1)? {dest_y,dest_x} : {dest_l,dest_y,dest_x};
 
        endp_addr_decoder  #(
                        .T1(T1),
                        .T2(T2),
                        .T3(T3),
                        .NE(NE),
                        .EAw(EAw),
                        .TOPOLOGY(TOPOLOGY)
                )enc
                (
                        .code(dest_e_addr),
                        .id(dest_ip_num)
                );
 
 
 
    end  else if( TRAFFIC == "BIT_REVERSE") begin :bitreverse
 
        for(i=0; i<(EAw); i=i+1'b1) begin :lp//reverse the address
            assign dest_ip_num[i]  = current_e_addr [((EAw)-1)-i];
        end
 
        endp_addr_encoder #(
            .T1(T1),
            .T2(T2),
            .T3(T3),
            .NE(NE),
            .EAw(EAw),
            .TOPOLOGY(TOPOLOGY)
        )
        addr_encoder(
            .id(dest_ip_num),
            .code(dest_e_addr)
        );
 
 
    end  else if( TRAFFIC == "BIT_COMPLEMENT") begin :bitcomp
 
        assign dest_x   = ~current_x;
        assign dest_y   = ~current_y;
        assign dest_l   = ~dest_l;
        assign dest_e_addr = (T3==1)? {dest_y,dest_x} : {dest_l,dest_y,dest_x};
 
        endp_addr_decoder  #(
                        .T1(T1),
                        .T2(T2),
                        .T3(T3),
                        .NE(NE),
                        .EAw(EAw),
                        .TOPOLOGY(TOPOLOGY)
                )enc
                (
                        .code(dest_e_addr),
                        .id(dest_ip_num)
                );
 
 
 
 
    end else if( TRAFFIC == "TORNADO" ) begin :tornado
        //[(x+(k/2-1)) mod k, (y+(k/2-1)) mod k],
        assign dest_x  = (current_x> ((NX+1)/2))? current_x- ((NX+1)/2) -1   :  (NX/2)+current_x-1;  //  = ((current_x + ((NX/2)-1))%NX);
        assign dest_y  = (current_y> ((NY+1)/2))? current_y- ((NY+1)/2) -1   :  (NY/2)+current_y-1;  //  = ((current_y + ((NY/2)-1))%NY);
        assign dest_l   = current_l;
        assign dest_e_addr = (T3==1)? {dest_y,dest_x} : {dest_l,dest_y,dest_x};
 
        endp_addr_decoder  #(
                        .T1(T1),
                        .T2(T2),
                        .T3(T3),
                        .NE(NE),
                        .EAw(EAw),
                        .TOPOLOGY(TOPOLOGY)
                )enc
                (
                        .code(dest_e_addr),
                        .id(dest_ip_num)
                );
 
 
 
 
        end else if( TRAFFIC == "NEIGHBOR")  begin :neighbor
                //dx = sx + 1 mod k
                 assign dest_x = (current_x + 1) >= NX? 0 : (current_x + 1);
                 assign dest_y = (current_y + 1) >= NY? 0 : (current_y + 1);
                 assign dest_l = current_l;
                 assign dest_e_addr = (T3==1)? {dest_y,dest_x} : {dest_l,dest_y,dest_x};
 
                 endp_addr_decoder  #(
                                .T1(T1),
                                .T2(T2),
                                .T3(T3),
                                .NE(NE),
                                .EAw(EAw),
                                .TOPOLOGY(TOPOLOGY)
                        )enc
                        (
                                .code(dest_e_addr),
                                .id(dest_ip_num)
                        );
 
 
 
 
        end else if( TRAFFIC == "SHUFFLE") begin: shuffle
                //di = si−1 mod b
                for(i=1; i<(EAw); i=i+1'b1) begin :lp//reverse the address
            assign dest_ip_num[i]  = current_e_addr [i-1];
        end
                assign dest_ip_num[0]  = current_e_addr [EAw-1];
                 endp_addr_encoder #(
            .T1(T1),
            .T2(T2),
            .T3(T3),
            .NE(NE),
            .EAw(EAw),
            .TOPOLOGY(TOPOLOGY)
        )
        addr_encoder(
            .id(dest_ip_num),
            .code(dest_e_addr)
        );
 
 
    end else if(TRAFFIC == "BIT_ROTATION") begin :bitrot
                //di = si+1 mod b
                for(i=0; i<(EAw-1); i=i+1'b1) begin :lp//reverse the address
            assign dest_ip_num[i]  = current_e_addr [i+1];
        end
                assign dest_ip_num[EAw-1]  = current_e_addr [0];
                endp_addr_encoder #(
            .T1(T1),
            .T2(T2),
            .T3(T3),
            .NE(NE),
            .EAw(EAw),
            .TOPOLOGY(TOPOLOGY)
        )
        addr_encoder(
            .id(dest_ip_num),
            .code(dest_e_addr)
        );
 
        end else if(TRAFFIC == "CUSTOM" )begin
 
        assign dest_ip_num = custom_traffic_t;
                 endp_addr_encoder #(
            .T1(T1),
            .T2(T2),
            .T3(T3),
            .NE(NE),
            .EAw(EAw),
            .TOPOLOGY(TOPOLOGY)
        )
        addr_encoder
        (
            .id(dest_ip_num),
            .code(dest_e_addr)
        );
 
                assign  off_flag  =  ~custom_traffic_en;
 
 
    end  else begin
                        initial begin
                                $display("ERROR: Undefined Traffic pattern:%s",TRAFFIC);
                                $stop;
                        end
        end
 
 
 
        wire valid_temp  =    (dest_ip_num  <= (NE-1));
 
        if (TRAFFIC == "HOTSPOT" || TRAFFIC == "CUSTOM") begin
                assign valid_dst  = ~off_flag & valid_temp;
        end else begin
                assign valid_dst  =  valid_temp;
        end
 
 
    endgenerate
 
endmodule
 
 
 
/************
 
************/
 
 
module one_dimension_pck_dst_gen
import pronoc_pkg::*;
#(
                parameter NE=4,
                parameter TRAFFIC =   "RANDOM",
                parameter MAX_PCK_NUM = 10000,
                parameter HOTSPOT_NODE_NUM =  4
 
)(
    en,
    core_num,
    pck_number,
    current_e_addr,
    dest_e_addr,
    clk,
    reset,
    valid_dst,
    hotspot_info,
        custom_traffic_t,
        custom_traffic_en
);
 
    function integer log2;
      input integer number; begin
         log2=(number <=1) ? 1: 0;
         while(2**log2
            log2=log2+1;
         end
      end
    endfunction // log2
 
 
     localparam
        NEw= log2(NE),
        PCK_CNTw = log2(MAX_PCK_NUM+1),
        HOTSPOT_NUM= (TRAFFIC=="HOTSPOT")? HOTSPOT_NODE_NUM : 1;
 
    input   reset,clk,en;
    input   [NEw-1 : 0] core_num;
    input   [PCK_CNTw-1  :   0]  pck_number;
    input   [EAw-1       :   0]  current_e_addr;
    output  [EAw-1       :   0]  dest_e_addr;
    output  valid_dst;
    input hotspot_t  hotspot_info [HOTSPOT_NUM-1 : 0];
        input  [NEw-1 : 0] custom_traffic_t;
        input  custom_traffic_en;
 
    wire [NEw-1 : 0] dest_ip_num;
    wire off_flag;
    genvar i;
    generate
    if (TRAFFIC == "RANDOM") begin
        logic [6 : 0] rnd_reg;
 
        always @(posedge clk ) begin
                if(en | reset) begin
                        rnd_reg =     $urandom_range(NE-1,0);
                        if(SELF_LOOP_EN == "NO")        while(rnd_reg==core_num) rnd_reg =     $urandom_range(NE-1,0);// get a random IP core, make sure its not same as sender core
                end
        end
        assign dest_ip_num = rnd_reg;
 
 
     end else if (TRAFFIC == "HOTSPOT") begin
 
        hot_spot_dest_gen  #(
                .HOTSPOT_NUM(HOTSPOT_NUM),
                .NE(NE),
                .NEw(NEw)
                )hspot
                (
                .clk(clk),
                .en(en),
                .hotspot_info(hotspot_info),
                .dest_ip_num (dest_ip_num),
                .core_num(core_num),
                .off_flag(off_flag)
        );
 
 
 
    end else if( TRAFFIC == "TRANSPOSE1") begin :tran1
 
        assign dest_ip_num   = NE-core_num-1;
 
    end  else if( TRAFFIC == "BIT_REVERSE") begin :bitreverse
 
        for(i=0; i
            assign dest_ip_num[i]  = core_num [NEw-1-i];
        end
 
    end  else if( TRAFFIC == "BIT_COMPLEMENT") begin :bitcomp
 
            assign dest_ip_num   = ~core_num;
 
    end else if( TRAFFIC == "TORNADO" ) begin :tornado
        //[(x+(k/2-1)) mod k, (y+(k/2-1)) mod k],
          assign dest_ip_num  = (core_num > ((NE+1)/2))? core_num- ((NE+1)/2) -1   :  (NE/2)+core_num-1;  //  = ((current_x + ((NX/2)-1))%NX);
 
        end else if( TRAFFIC == "NEIGHBOR")  begin :neighbor
                //dx = sx + 1 mod k
                 assign dest_ip_num = ((core_num + 1) >= NE) ? 0 : (core_num + 1);
 
        end else if( TRAFFIC == "SHUFFLE") begin: shuffle
                //di = si−1 mod b
                for(i=1; i<(NEw); i=i+1'b1) begin :lp
            assign dest_ip_num[i]  = core_num [i-1];
        end
                assign dest_ip_num[0]  = core_num [NEw-1];
 
    end else if(TRAFFIC == "BIT_ROTATION") begin :bitrot
                //di = si+1 mod b
                for(i=0; i<(NEw-1); i=i+1) begin :lp//reverse the address
            assign dest_ip_num[i]  = core_num [i+1];
        end
                assign dest_ip_num[NEw-1]  = core_num [0];
 
        end else if(TRAFFIC == "CUSTOM" )begin
                assign off_flag = ~custom_traffic_en;
         assign dest_ip_num = custom_traffic_t;
    end
 
    endp_addr_encoder #(
        .T1(T1),
        .T2(T2),
        .T3(T3),
        .NE(NE),
        .EAw(EAw),
        .TOPOLOGY(TOPOLOGY)
    )
    addr_encoder
    (
        .id(dest_ip_num),
        .code(dest_e_addr)
    );
 
    wire valid_temp  =    (dest_ip_num  <= (NE-1));
 
    if (TRAFFIC == "HOTSPOT" || TRAFFIC == "CUSTOM") begin
        assign valid_dst  = ~off_flag & valid_temp;
    end else begin
        assign valid_dst  =  valid_temp;
    end
 
    endgenerate
 
endmodule
 
/***************************
 *  pck_size_gen
 * *************************/
 
module pck_size_gen
                import pronoc_pkg::*;
#(
                parameter PCK_SIZw=4,
        parameter MIN = 2,
        parameter MAX = 5,
        parameter PCK_SIZ_SEL="random-discrete",
        parameter DISCRETE_PCK_SIZ_NUM=1
)
(
    reset,
    clk,
    en,
    pck_size,
    rnd_discrete
);
 
        input rnd_discrete_t rnd_discrete [DISCRETE_PCK_SIZ_NUM-1: 0];
 
 
    input reset, clk, en;
    output [PCK_SIZw-1 : 0] pck_size;
 
 
    generate
        if(PCK_SIZ_SEL == "random-discrete"     ) begin :discrete
                if(DISCRETE_PCK_SIZ_NUM==1) begin :single
                        assign pck_size = rnd_discrete[0].value;
                end else begin :multi
                        reg [PCK_SIZw-1 : 0] rnd,rnd_next;
                        integer rnd2;
                        integer k;
                        always @(*) begin
                                rnd_next = rnd;
                                if(en) begin
                                        if(rnd2 < rnd_discrete[0].percentage) rnd_next = rnd_discrete[0].value;
                                        for (k=1;k
                                                if(rnd2 >= rnd_discrete[k-1].percentage && rnd2 < rnd_discrete[k].percentage) rnd_next = rnd_discrete[k].value;
                                        end
                                end
                        end//always
 
 
                        always @(posedge clk) begin
                                if(reset)  begin
                                        rnd2<= 0;
                                        rnd <= rnd_discrete[0].value;
                                end else  begin
                                        if(en) rnd2<= $urandom_range(99,0);
                                        rnd <= rnd_next;
                                end
                        end//always
 
                        assign pck_size = rnd;
                end//multi
 
        end else begin :range
                if (MIN == MAX) begin :eq
                assign pck_size = MIN;
            end  else begin :noteq
                reg [PCK_SIZw-1 : 0] rnd;
                always @(posedge clk) begin
                    if(reset) rnd = MIN;
                    else if(en) rnd = $urandom_range(MAX,MIN);
                end
                assign pck_size = rnd;
            end
        end
        endgenerate
endmodule
 
 
 
 
module hot_spot_dest_gen
        import pronoc_pkg::*;
#(
        parameter HOTSPOT_NUM=2,
        parameter NE=16,
        parameter NEw=4
)
(
clk,
reset,
en,
hotspot_info,
core_num,
dest_ip_num,
off_flag
);
 
        input clk,en,reset;
        input hotspot_t  hotspot_info [HOTSPOT_NUM-1 : 0];
        input   [NEw-1 : 0] core_num;
        output  [NEw-1 : 0] dest_ip_num;
        output reg off_flag;
 
        logic [6 : 0] rnd_reg, hotspot_node;
        reg [9 : 0] rnd1000;
        always @(posedge clk ) begin
                if(en | reset) begin
                        rnd_reg =     $urandom_range(NE-1,0);
                        if(SELF_LOOP_EN == "NO")        while(rnd_reg==core_num) rnd_reg =     $urandom_range(NE-1,0);// get a random IP core, make sure its not same as sender core
 
                        rnd1000 =     $urandom_range(999,0);// generate a random number between 0 & 1000
                end
        end
 
        logic hotspot_flag;
        integer i;
 
        always @(*)begin
                off_flag=0;
                for (i=0;i
                        if ( hotspot_info[i].send_enable == 0 && core_num ==hotspot_info[i].ip_num)begin
                                off_flag=1;
                        end
                end
                hotspot_flag=0;
                hotspot_node=0;
                if ( rnd1000 < hotspot_info[0].percentage && core_num !=hotspot_info[0].ip_num)begin
                        hotspot_flag=1;
                        hotspot_node=hotspot_info[0].ip_num;
                end else begin
                        for (i=1;i
                                if (rnd1000 >= hotspot_info[i-1].percentage && rnd1000 < hotspot_info[i].percentage && core_num !=hotspot_info[i].ip_num) begin
                                        hotspot_flag=1;
                                        hotspot_node=hotspot_info[i].ip_num;
                                end
                        end end
 
        end
 
 
        assign dest_ip_num = (off_flag)? core_num : (hotspot_flag)? hotspot_node : rnd_reg;
 
 
endmodule

Browse

Tools

Subversion Repositories an-fpga-implementation-of-low-latency-noc-based-mpsoc

[/] [an-fpga-implementation-of-low-latency-noc-based-mpsoc/] [trunk/] [mpsoc/] [rtl/] [src_modelsim/] [traffic_pattern.sv] - Blame information for rev 48

Line No.	Rev	Author	Line
1	48	alirezamon	`/**************************************`
2			`* Module: traffic_pattern`
3			`* Date:2015-10-05`
4			`* Author: alireza`
5			`*`
6			`* Description:`
7			`***************************************/`
8
9			`timescale 1ns/1ps
10
11
12
13			`/************************************`
14
15			`pck_class_in_gen`
16
17			`***********************************/`
18
19			`module pck_class_in_gen #(`
20			`parameter C = 4, // number of packet class`
21			`parameter C0_p = 25, // the percentage of injected packets with class 0`
22			`parameter C1_p = 25,`
23			`parameter C2_p = 25,`
24			`parameter C3_p = 25`
25			`)(`
26			`pck_class_o,`
27			`en,`
28			`reset,`
29			`clk`
30
31			`);`
32
33			`function integer log2;`
34			`input integer number; begin`
35			`log2=(number <=1) ? 1: 0;`
36			`while(2**log2`
37			`log2=log2+1;`
38			`end`
39			`end`
40			`endfunction // log2`
41
42
43			`localparam`
44			`Cw = (C>1)? log2(C) : 1,`
45			`RNDw = log2(100);`
46
47			`output reg [Cw-1 : 0] pck_class_o;`
48			`input reset,clk,en;`
49			`reg [RNDw-1 : 0] rnd;`
50
51
52
53			`// generate a random num between 0 to 99`
54			`always @(posedge clk ) begin`
55			`if(en \| reset) begin`
56			`rnd = $urandom_range(99,0);`
57			`end`
58			`end`
59
60			`always @(*) begin`
61			`if ( rnd < C0_p) pck_class_o =0;`
62			`else if ( rnd < (C0_p+C1_p)) pck_class_o =1;`
63			`else if ( rnd < (C0_p+C1_p+C2_p)) pck_class_o =2;`
64			`else pck_class_o =3;`
65			`end`
66
67
68
69			`endmodule`
70
71			`/**********************************`
72
73			`pck_dst_gen`
74
75			`*********************************/`
76
77
78			`module pck_dst_gen`
79			`import pronoc_pkg::*;`
80			`#(`
81			`parameter NE=4,`
82			`parameter TRAFFIC = "RANDOM",`
83			`parameter MAX_PCK_NUM = 10000,`
84			`parameter HOTSPOT_NODE_NUM = 4`
85			`)(`
86			`en,`
87			`current_e_addr,`
88			`core_num,`
89			`pck_number,`
90			`dest_e_addr,`
91			`clk,`
92			`reset,`
93			`valid_dst,`
94			`hotspot_info,`
95			`custom_traffic_t,`
96			`custom_traffic_en`
97			`);`
98
99
100			`localparam ADDR_DIMENSION = (TOPOLOGY == "MESH" \|\| TOPOLOGY == "TORUS") ? 2 : 1; // "RING" and FULLY_CONNECT`
101
102
103			`function integer log2;`
104			`input integer number; begin`
105			`log2=(number <=1) ? 1: 0;`
106			`while(2**log2`
107			`log2=log2+1;`
108			`end`
109			`end`
110			`endfunction // log2`
111
112
113			`localparam NEw= log2(NE),`
114			`PCK_CNTw = log2(MAX_PCK_NUM+1),`
115			`HOTSPOT_NUM= (TRAFFIC=="HOTSPOT")? HOTSPOT_NODE_NUM : 1;`
116
117			`input reset,clk,en;`
118			`input [NEw-1 : 0] core_num;`
119			`input [PCK_CNTw-1 : 0] pck_number;`
120			`input [EAw-1 : 0] current_e_addr;`
121			`output [EAw-1 : 0] dest_e_addr;`
122			`output valid_dst;`
123			`input [NEw-1 : 0] custom_traffic_t;`
124			`input custom_traffic_en;`
125
126			`input hotspot_t hotspot_info [HOTSPOT_NUM-1 : 0];`
127
128
129			`generate`
130			`if ( ADDR_DIMENSION == 2) begin :two_dim`
131
132			`two_dimension_pck_dst_gen #(`
133			`.NE(NE),`
134			`.TRAFFIC(TRAFFIC),`
135			`.MAX_PCK_NUM(MAX_PCK_NUM),`
136			`.HOTSPOT_NODE_NUM(HOTSPOT_NODE_NUM)`
137
138			`)`
139			`the_two_dimension_pck_dst_gen`
140			`(`
141			`.reset(reset),`
142			`.clk(clk),`
143			`.en(en),`
144			`.core_num(core_num),`
145			`.pck_number(pck_number),`
146			`.current_e_addr(current_e_addr),`
147			`.dest_e_addr(dest_e_addr),`
148			`.valid_dst(valid_dst),`
149			`.hotspot_info(hotspot_info),`
150			`.custom_traffic_t(custom_traffic_t),`
151			`.custom_traffic_en(custom_traffic_en)`
152			`);`
153
154			`end else begin : one_dim`
155
156			`one_dimension_pck_dst_gen #(`
157			`.NE(NE),`
158			`.TRAFFIC(TRAFFIC),`
159			`.MAX_PCK_NUM(MAX_PCK_NUM),`
160			`.HOTSPOT_NODE_NUM(HOTSPOT_NODE_NUM)`
161			`)`
162			`the_one_dimension_pck_dst_gen`
163			`(`
164			`.reset(reset),`
165			`.clk(clk),`
166			`.en(en),`
167			`.core_num(core_num),`
168			`.pck_number(pck_number),`
169			`.current_e_addr(current_e_addr),`
170			`.dest_e_addr(dest_e_addr),`
171			`.valid_dst(valid_dst),`
172			`.hotspot_info(hotspot_info),`
173			`.custom_traffic_t(custom_traffic_t),`
174			`.custom_traffic_en(custom_traffic_en)`
175			`);`
176
177			`end`
178			`endgenerate`
179			`endmodule`
180
181
182
183
184			`module two_dimension_pck_dst_gen`
185			`import pronoc_pkg::*;`
186			`#(`
187			`parameter NE=4,`
188			`parameter TRAFFIC = "RANDOM",`
189			`parameter MAX_PCK_NUM = 10000,`
190			`parameter HOTSPOT_NODE_NUM = 4`
191
192			`)(`
193			`en,`
194			`current_e_addr,`
195			`dest_e_addr,`
196			`core_num,`
197			`pck_number,`
198			`clk,`
199			`reset,`
200			`valid_dst,`
201			`hotspot_info,`
202			`custom_traffic_t,`
203			`custom_traffic_en`
204			`);`
205
206
207			`function integer log2;`
208			`input integer number; begin`
209			`log2=(number <=1) ? 1: 0;`
210			`while(2**log2`
211			`log2=log2+1;`
212			`end`
213			`end`
214			`endfunction // log2`
215
216
217			`localparam NEw= log2(NE),`
218			`PCK_CNTw = log2(MAX_PCK_NUM+1),`
219			`HOTSPOT_NUM= (TRAFFIC=="HOTSPOT")? HOTSPOT_NODE_NUM : 1;`
220
221			`input reset,clk,en;`
222			`input [NEw-1 : 0] core_num;`
223			`input [PCK_CNTw-1 : 0] pck_number;`
224			`input [EAw-1 : 0] current_e_addr;`
225			`output [EAw-1 : 0] dest_e_addr;`
226			`output valid_dst;`
227			`input hotspot_t hotspot_info [HOTSPOT_NUM-1 : 0];`
228			`input [NEw-1 : 0] custom_traffic_t;`
229			`input custom_traffic_en;`
230
231			`localparam`
232			`NX = T1,`
233			`NY = T2,`
234			`NL = T3,`
235			`NXw = log2(NX),`
236			`NYw= log2(NY),`
237			`NLw= log2(NL);`
238
239			`wire [NXw-1 : 0] current_x;`
240			`wire [NYw-1 : 0] current_y;`
241			`wire [NLw-1 : 0] current_l;`
242			`wire [NXw-1 : 0] dest_x;`
243			`wire [NYw-1 : 0] dest_y;`
244			`wire [NLw-1 : 0] dest_l;`
245
246			`mesh_tori_endp_addr_decode #(`
247			`.TOPOLOGY(TOPOLOGY),`
248			`.T1(T1),`
249			`.T2(T2),`
250			`.T3(T3),`
251			`.EAw(EAw)`
252			`)`
253			`src_addr_decode`
254			`(`
255			`.e_addr(current_e_addr),`
256			`.ex(current_x),`
257			`.ey(current_y),`
258			`.el(current_l),`
259			`.valid( )`
260			`);`
261
262			`wire off_flag;`
263
264
265
266
267
268			`wire [NEw-1 : 0] dest_ip_num;`
269			`genvar i;`
270
271			`generate`
272			`if (TRAFFIC == "RANDOM") begin`
273
274			`logic [6 : 0] rnd_reg;`
275
276			`always @(posedge clk ) begin`
277			`if(en \| reset) begin`
278			`rnd_reg = $urandom_range(NE-1,0);`
279			`if(SELF_LOOP_EN == "NO") while(rnd_reg==core_num) rnd_reg = $urandom_range(NE-1,0);// get a random IP core, make sure its not same as sender core`
280
281			`end`
282			`end`
283			`assign dest_ip_num = rnd_reg;`
284
285			`endp_addr_encoder #(`
286			`.T1(T1),`
287			`.T2(T2),`
288			`.T3(T3),`
289			`.NE(NE),`
290			`.EAw(EAw),`
291			`.TOPOLOGY(TOPOLOGY)`
292			`)`
293			`addr_encoder`
294			`(`
295			`.id(dest_ip_num),`
296			`.code(dest_e_addr)`
297			`);`
298
299			`end else if (TRAFFIC == "HOTSPOT") begin`
300
301			`hot_spot_dest_gen #(`
302			`.HOTSPOT_NUM(HOTSPOT_NUM),`
303			`.NE(NE),`
304			`.NEw(NEw)`
305			`)hspot`
306			`(`
307			`.reset(reset),`
308			`.clk(clk),`
309			`.en(en),`
310			`.hotspot_info(hotspot_info),`
311			`.dest_ip_num (dest_ip_num),`
312			`.core_num(core_num),`
313			`.off_flag(off_flag)`
314			`);`
315
316			`endp_addr_encoder #(`
317			`.T1(T1),`
318			`.T2(T2),`
319			`.T3(T3),`
320			`.NE(NE),`
321			`.EAw(EAw),`
322			`.TOPOLOGY(TOPOLOGY)`
323			`)`
324			`addr_encoder`
325			`(`
326			`.id(dest_ip_num),`
327			`.code(dest_e_addr)`
328			`);`
329
330
331
332			`end else if( TRAFFIC == "TRANSPOSE1") begin`
333
334			`assign dest_x = NX-current_y-1;`
335			`assign dest_y = NY-current_x-1;`
336			`assign dest_l = NL-current_l-1;`
337			`assign dest_e_addr = (T3==1)? {dest_y,dest_x} : {dest_l,dest_y,dest_x};`
338
339			`endp_addr_decoder #(`
340			`.T1(T1),`
341			`.T2(T2),`
342			`.T3(T3),`
343			`.NE(NE),`
344			`.EAw(EAw),`
345			`.TOPOLOGY(TOPOLOGY)`
346			`)enc`
347			`(`
348			`.code(dest_e_addr),`
349			`.id(dest_ip_num)`
350			`);`
351
352
353
354
355
356
357			`end else if( TRAFFIC == "TRANSPOSE2") begin :transpose2`
358
359			`assign dest_x = current_y;`
360			`assign dest_y = current_x;`
361			`assign dest_l = current_l;`
362			`assign dest_e_addr = (T3==1)? {dest_y,dest_x} : {dest_l,dest_y,dest_x};`
363
364			`endp_addr_decoder #(`
365			`.T1(T1),`
366			`.T2(T2),`
367			`.T3(T3),`
368			`.NE(NE),`
369			`.EAw(EAw),`
370			`.TOPOLOGY(TOPOLOGY)`
371			`)enc`
372			`(`
373			`.code(dest_e_addr),`
374			`.id(dest_ip_num)`
375			`);`
376
377
378
379			`end else if( TRAFFIC == "BIT_REVERSE") begin :bitreverse`
380
381			`for(i=0; i<(EAw); i=i+1'b1) begin :lp//reverse the address`
382			`assign dest_ip_num[i] = current_e_addr [((EAw)-1)-i];`
383			`end`
384
385			`endp_addr_encoder #(`
386			`.T1(T1),`
387			`.T2(T2),`
388			`.T3(T3),`
389			`.NE(NE),`
390			`.EAw(EAw),`
391			`.TOPOLOGY(TOPOLOGY)`
392			`)`
393			`addr_encoder(`
394			`.id(dest_ip_num),`
395			`.code(dest_e_addr)`
396			`);`
397
398
399			`end else if( TRAFFIC == "BIT_COMPLEMENT") begin :bitcomp`
400
401			`assign dest_x = ~current_x;`
402			`assign dest_y = ~current_y;`
403			`assign dest_l = ~dest_l;`
404			`assign dest_e_addr = (T3==1)? {dest_y,dest_x} : {dest_l,dest_y,dest_x};`
405
406			`endp_addr_decoder #(`
407			`.T1(T1),`
408			`.T2(T2),`
409			`.T3(T3),`
410			`.NE(NE),`
411			`.EAw(EAw),`
412			`.TOPOLOGY(TOPOLOGY)`
413			`)enc`
414			`(`
415			`.code(dest_e_addr),`
416			`.id(dest_ip_num)`
417			`);`
418
419
420
421
422			`end else if( TRAFFIC == "TORNADO" ) begin :tornado`
423			`//[(x+(k/2-1)) mod k, (y+(k/2-1)) mod k],`
424			`assign dest_x = (current_x> ((NX+1)/2))? current_x- ((NX+1)/2) -1 : (NX/2)+current_x-1; // = ((current_x + ((NX/2)-1))%NX);`
425			`assign dest_y = (current_y> ((NY+1)/2))? current_y- ((NY+1)/2) -1 : (NY/2)+current_y-1; // = ((current_y + ((NY/2)-1))%NY);`
426			`assign dest_l = current_l;`
427			`assign dest_e_addr = (T3==1)? {dest_y,dest_x} : {dest_l,dest_y,dest_x};`
428
429			`endp_addr_decoder #(`
430			`.T1(T1),`
431			`.T2(T2),`
432			`.T3(T3),`
433			`.NE(NE),`
434			`.EAw(EAw),`
435			`.TOPOLOGY(TOPOLOGY)`
436			`)enc`
437			`(`
438			`.code(dest_e_addr),`
439			`.id(dest_ip_num)`
440			`);`
441
442
443
444
445			`end else if( TRAFFIC == "NEIGHBOR") begin :neighbor`
446			`//dx = sx + 1 mod k`
447			`assign dest_x = (current_x + 1) >= NX? 0 : (current_x + 1);`
448			`assign dest_y = (current_y + 1) >= NY? 0 : (current_y + 1);`
449			`assign dest_l = current_l;`
450			`assign dest_e_addr = (T3==1)? {dest_y,dest_x} : {dest_l,dest_y,dest_x};`
451
452			`endp_addr_decoder #(`
453			`.T1(T1),`
454			`.T2(T2),`
455			`.T3(T3),`
456			`.NE(NE),`
457			`.EAw(EAw),`
458			`.TOPOLOGY(TOPOLOGY)`
459			`)enc`
460			`(`
461			`.code(dest_e_addr),`
462			`.id(dest_ip_num)`
463			`);`
464
465
466
467
468			`end else if( TRAFFIC == "SHUFFLE") begin: shuffle`
469			`//di = si−1 mod b`
470			`for(i=1; i<(EAw); i=i+1'b1) begin :lp//reverse the address`
471			`assign dest_ip_num[i] = current_e_addr [i-1];`
472			`end`
473			`assign dest_ip_num[0] = current_e_addr [EAw-1];`
474			`endp_addr_encoder #(`
475			`.T1(T1),`
476			`.T2(T2),`
477			`.T3(T3),`
478			`.NE(NE),`
479			`.EAw(EAw),`
480			`.TOPOLOGY(TOPOLOGY)`
481			`)`
482			`addr_encoder(`
483			`.id(dest_ip_num),`
484			`.code(dest_e_addr)`
485			`);`
486
487
488			`end else if(TRAFFIC == "BIT_ROTATION") begin :bitrot`
489			`//di = si+1 mod b`
490			`for(i=0; i<(EAw-1); i=i+1'b1) begin :lp//reverse the address`
491			`assign dest_ip_num[i] = current_e_addr [i+1];`
492			`end`
493			`assign dest_ip_num[EAw-1] = current_e_addr [0];`
494			`endp_addr_encoder #(`
495			`.T1(T1),`
496			`.T2(T2),`
497			`.T3(T3),`
498			`.NE(NE),`
499			`.EAw(EAw),`
500			`.TOPOLOGY(TOPOLOGY)`
501			`)`
502			`addr_encoder(`
503			`.id(dest_ip_num),`
504			`.code(dest_e_addr)`
505			`);`
506
507			`end else if(TRAFFIC == "CUSTOM" )begin`
508
509			`assign dest_ip_num = custom_traffic_t;`
510			`endp_addr_encoder #(`
511			`.T1(T1),`
512			`.T2(T2),`
513			`.T3(T3),`
514			`.NE(NE),`
515			`.EAw(EAw),`
516			`.TOPOLOGY(TOPOLOGY)`
517			`)`
518			`addr_encoder`
519			`(`
520			`.id(dest_ip_num),`
521			`.code(dest_e_addr)`
522			`);`
523
524			`assign off_flag = ~custom_traffic_en;`
525
526
527			`end else begin`
528			`initial begin`
529			`$display("ERROR: Undefined Traffic pattern:%s",TRAFFIC);`
530			`$stop;`
531			`end`
532			`end`
533
534
535
536			`wire valid_temp = (dest_ip_num <= (NE-1));`
537
538			`if (TRAFFIC == "HOTSPOT" \|\| TRAFFIC == "CUSTOM") begin`
539			`assign valid_dst = ~off_flag & valid_temp;`
540			`end else begin`
541			`assign valid_dst = valid_temp;`
542			`end`
543
544
545			`endgenerate`
546
547			`endmodule`
548
549
550
551			`/************`
552
553			`************/`
554
555
556			`module one_dimension_pck_dst_gen`
557			`import pronoc_pkg::*;`
558			`#(`
559			`parameter NE=4,`
560			`parameter TRAFFIC = "RANDOM",`
561			`parameter MAX_PCK_NUM = 10000,`
562			`parameter HOTSPOT_NODE_NUM = 4`
563
564			`)(`
565			`en,`
566			`core_num,`
567			`pck_number,`
568			`current_e_addr,`
569			`dest_e_addr,`
570			`clk,`
571			`reset,`
572			`valid_dst,`
573			`hotspot_info,`
574			`custom_traffic_t,`
575			`custom_traffic_en`
576			`);`
577
578			`function integer log2;`
579			`input integer number; begin`
580			`log2=(number <=1) ? 1: 0;`
581			`while(2**log2`
582			`log2=log2+1;`
583			`end`
584			`end`
585			`endfunction // log2`
586
587
588			`localparam`
589			`NEw= log2(NE),`
590			`PCK_CNTw = log2(MAX_PCK_NUM+1),`
591			`HOTSPOT_NUM= (TRAFFIC=="HOTSPOT")? HOTSPOT_NODE_NUM : 1;`
592
593			`input reset,clk,en;`
594			`input [NEw-1 : 0] core_num;`
595			`input [PCK_CNTw-1 : 0] pck_number;`
596			`input [EAw-1 : 0] current_e_addr;`
597			`output [EAw-1 : 0] dest_e_addr;`
598			`output valid_dst;`
599			`input hotspot_t hotspot_info [HOTSPOT_NUM-1 : 0];`
600			`input [NEw-1 : 0] custom_traffic_t;`
601			`input custom_traffic_en;`
602
603			`wire [NEw-1 : 0] dest_ip_num;`
604			`wire off_flag;`
605			`genvar i;`
606			`generate`
607			`if (TRAFFIC == "RANDOM") begin`
608			`logic [6 : 0] rnd_reg;`
609
610			`always @(posedge clk ) begin`
611			`if(en \| reset) begin`
612			`rnd_reg = $urandom_range(NE-1,0);`
613			`if(SELF_LOOP_EN == "NO") while(rnd_reg==core_num) rnd_reg = $urandom_range(NE-1,0);// get a random IP core, make sure its not same as sender core`
614			`end`
615			`end`
616			`assign dest_ip_num = rnd_reg;`
617
618
619			`end else if (TRAFFIC == "HOTSPOT") begin`
620
621			`hot_spot_dest_gen #(`
622			`.HOTSPOT_NUM(HOTSPOT_NUM),`
623			`.NE(NE),`
624			`.NEw(NEw)`
625			`)hspot`
626			`(`
627			`.clk(clk),`
628			`.en(en),`
629			`.hotspot_info(hotspot_info),`
630			`.dest_ip_num (dest_ip_num),`
631			`.core_num(core_num),`
632			`.off_flag(off_flag)`
633			`);`
634
635
636
637			`end else if( TRAFFIC == "TRANSPOSE1") begin :tran1`
638
639			`assign dest_ip_num = NE-core_num-1;`
640
641			`end else if( TRAFFIC == "BIT_REVERSE") begin :bitreverse`
642
643			`for(i=0; i`
644			`assign dest_ip_num[i] = core_num [NEw-1-i];`
645			`end`
646
647			`end else if( TRAFFIC == "BIT_COMPLEMENT") begin :bitcomp`
648
649			`assign dest_ip_num = ~core_num;`
650
651			`end else if( TRAFFIC == "TORNADO" ) begin :tornado`
652			`//[(x+(k/2-1)) mod k, (y+(k/2-1)) mod k],`
653			`assign dest_ip_num = (core_num > ((NE+1)/2))? core_num- ((NE+1)/2) -1 : (NE/2)+core_num-1; // = ((current_x + ((NX/2)-1))%NX);`
654
655			`end else if( TRAFFIC == "NEIGHBOR") begin :neighbor`
656			`//dx = sx + 1 mod k`
657			`assign dest_ip_num = ((core_num + 1) >= NE) ? 0 : (core_num + 1);`
658
659			`end else if( TRAFFIC == "SHUFFLE") begin: shuffle`
660			`//di = si−1 mod b`
661			`for(i=1; i<(NEw); i=i+1'b1) begin :lp`
662			`assign dest_ip_num[i] = core_num [i-1];`
663			`end`
664			`assign dest_ip_num[0] = core_num [NEw-1];`
665
666			`end else if(TRAFFIC == "BIT_ROTATION") begin :bitrot`
667			`//di = si+1 mod b`
668			`for(i=0; i<(NEw-1); i=i+1) begin :lp//reverse the address`
669			`assign dest_ip_num[i] = core_num [i+1];`
670			`end`
671			`assign dest_ip_num[NEw-1] = core_num [0];`
672
673			`end else if(TRAFFIC == "CUSTOM" )begin`
674			`assign off_flag = ~custom_traffic_en;`
675			`assign dest_ip_num = custom_traffic_t;`
676			`end`
677
678			`endp_addr_encoder #(`
679			`.T1(T1),`
680			`.T2(T2),`
681			`.T3(T3),`
682			`.NE(NE),`
683			`.EAw(EAw),`
684			`.TOPOLOGY(TOPOLOGY)`
685			`)`
686			`addr_encoder`
687			`(`
688			`.id(dest_ip_num),`
689			`.code(dest_e_addr)`
690			`);`
691
692			`wire valid_temp = (dest_ip_num <= (NE-1));`
693
694			`if (TRAFFIC == "HOTSPOT" \|\| TRAFFIC == "CUSTOM") begin`
695			`assign valid_dst = ~off_flag & valid_temp;`
696			`end else begin`
697			`assign valid_dst = valid_temp;`
698			`end`
699
700			`endgenerate`
701
702			`endmodule`
703
704			`/***************************`
705			`* pck_size_gen`
706			`* *************************/`
707
708			`module pck_size_gen`
709			`import pronoc_pkg::*;`
710			`#(`
711			`parameter PCK_SIZw=4,`
712			`parameter MIN = 2,`
713			`parameter MAX = 5,`
714			`parameter PCK_SIZ_SEL="random-discrete",`
715			`parameter DISCRETE_PCK_SIZ_NUM=1`
716			`)`
717			`(`
718			`reset,`
719			`clk,`
720			`en,`
721			`pck_size,`
722			`rnd_discrete`
723			`);`
724
725			`input rnd_discrete_t rnd_discrete [DISCRETE_PCK_SIZ_NUM-1: 0];`
726
727
728			`input reset, clk, en;`
729			`output [PCK_SIZw-1 : 0] pck_size;`
730
731
732			`generate`
733			`if(PCK_SIZ_SEL == "random-discrete" ) begin :discrete`
734			`if(DISCRETE_PCK_SIZ_NUM==1) begin :single`
735			`assign pck_size = rnd_discrete[0].value;`
736			`end else begin :multi`
737			`reg [PCK_SIZw-1 : 0] rnd,rnd_next;`
738			`integer rnd2;`
739			`integer k;`
740			`always @(*) begin`
741			`rnd_next = rnd;`
742			`if(en) begin`
743			`if(rnd2 < rnd_discrete[0].percentage) rnd_next = rnd_discrete[0].value;`
744			`for (k=1;k`
745			`if(rnd2 >= rnd_discrete[k-1].percentage && rnd2 < rnd_discrete[k].percentage) rnd_next = rnd_discrete[k].value;`
746			`end`
747			`end`
748			`end//always`
749
750
751			`always @(posedge clk) begin`
752			`if(reset) begin`
753			`rnd2<= 0;`
754			`rnd <= rnd_discrete[0].value;`
755			`end else begin`
756			`if(en) rnd2<= $urandom_range(99,0);`
757			`rnd <= rnd_next;`
758			`end`
759			`end//always`
760
761			`assign pck_size = rnd;`
762			`end//multi`
763
764			`end else begin :range`
765			`if (MIN == MAX) begin :eq`
766			`assign pck_size = MIN;`
767			`end else begin :noteq`
768			`reg [PCK_SIZw-1 : 0] rnd;`
769			`always @(posedge clk) begin`
770			`if(reset) rnd = MIN;`
771			`else if(en) rnd = $urandom_range(MAX,MIN);`
772			`end`
773			`assign pck_size = rnd;`
774			`end`
775			`end`
776			`endgenerate`
777			`endmodule`
778
779
780
781
782			`module hot_spot_dest_gen`
783			`import pronoc_pkg::*;`
784			`#(`
785			`parameter HOTSPOT_NUM=2,`
786			`parameter NE=16,`
787			`parameter NEw=4`
788			`)`
789			`(`
790			`clk,`
791			`reset,`
792			`en,`
793			`hotspot_info,`
794			`core_num,`
795			`dest_ip_num,`
796			`off_flag`
797			`);`
798
799			`input clk,en,reset;`
800			`input hotspot_t hotspot_info [HOTSPOT_NUM-1 : 0];`
801			`input [NEw-1 : 0] core_num;`
802			`output [NEw-1 : 0] dest_ip_num;`
803			`output reg off_flag;`
804
805			`logic [6 : 0] rnd_reg, hotspot_node;`
806			`reg [9 : 0] rnd1000;`
807			`always @(posedge clk ) begin`
808			`if(en \| reset) begin`
809			`rnd_reg = $urandom_range(NE-1,0);`
810			`if(SELF_LOOP_EN == "NO") while(rnd_reg==core_num) rnd_reg = $urandom_range(NE-1,0);// get a random IP core, make sure its not same as sender core`
811
812			`rnd1000 = $urandom_range(999,0);// generate a random number between 0 & 1000`
813			`end`
814			`end`
815
816			`logic hotspot_flag;`
817			`integer i;`
818
819			`always @(*)begin`
820			`off_flag=0;`
821			`for (i=0;i`
822			`if ( hotspot_info[i].send_enable == 0 && core_num ==hotspot_info[i].ip_num)begin`
823			`off_flag=1;`
824			`end`
825			`end`
826			`hotspot_flag=0;`
827			`hotspot_node=0;`
828			`if ( rnd1000 < hotspot_info[0].percentage && core_num !=hotspot_info[0].ip_num)begin`
829			`hotspot_flag=1;`
830			`hotspot_node=hotspot_info[0].ip_num;`
831			`end else begin`
832			`for (i=1;i`
833			`if (rnd1000 >= hotspot_info[i-1].percentage && rnd1000 < hotspot_info[i].percentage && core_num !=hotspot_info[i].ip_num) begin`
834			`hotspot_flag=1;`
835			`hotspot_node=hotspot_info[i].ip_num;`
836			`end`
837			`end end`
838
839			`end`
840
841
842			`assign dest_ip_num = (off_flag)? core_num : (hotspot_flag)? hotspot_node : rnd_reg;`
843
844
845			`endmodule`