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 56

Details | Compare with Previous | View Log


/**************************************
* Module: traffic_pattern
* Date:2015-10-05
* Author: alireza
*
* Description:
***************************************/
 
`include "pronoc_def.v"
 
 
 
/************************************
 
        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 | `pronoc_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
   #(
    parameter NOC_ID=0,
        parameter TRAFFIC = "RANDOM",
    parameter HOTSPOT_NODE_NUM =  4,
    parameter MCAST_TRAFFIC_RATIO =50,
    parameter MCAST_PCK_SIZ_MIN = 2,
    parameter MCAST_PCK_SIZ_MAX = 4,
    parameter MIN_PACKET_SIZE=5,
    parameter MAX_PACKET_SIZE=5,
    parameter PCK_SIZ_SEL="random-discrete",
    parameter DISCRETE_PCK_SIZ_NUM=1
 
)(
    en,
    current_e_addr,
    core_num,
    pck_number,
    dest_e_addr,
    clk,
    reset,
    valid_dst,
    hotspot_info,
    custom_traffic_t,
    custom_traffic_en,
    pck_size_o,
    rnd_discrete
 
 
);
 
    `NOC_CONF
 
    localparam      ADDR_DIMENSION =   (TOPOLOGY ==    "MESH" || TOPOLOGY ==  "TORUS") ? 2 : 1;  // "RING" and FULLY_CONNECT
 
 
 
 
    localparam  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  [DAw-1      :   0]  dest_e_addr;
    output                      valid_dst;
    input  [NEw-1 : 0] custom_traffic_t;
    input  custom_traffic_en;
 
 
    output [PCK_SIZw-1:0]  pck_size_o;
    input rnd_discrete_t rnd_discrete [DISCRETE_PCK_SIZ_NUM-1: 0];
 
    input hotspot_t  hotspot_info [HOTSPOT_NUM-1 : 0];
 
 
        wire [EAw-1      :   0] unicast_dest_e_addr;
        wire [PCK_SIZw-1 : 0] pck_size_uni;
 
        pck_dst_gen_unicast #(
                .NOC_ID(NOC_ID),
                .TRAFFIC(TRAFFIC),
                .HOTSPOT_NODE_NUM(HOTSPOT_NODE_NUM)
        )
        unicast
        (
                .en               (en              ),
                .current_e_addr   (current_e_addr  ),
                .core_num         (core_num        ),
                .pck_number       (pck_number      ),
                .dest_e_addr      (unicast_dest_e_addr),
                .clk              (clk             ),
                .reset            (reset           ),
                .valid_dst        (valid_dst       ),
                .hotspot_info     (hotspot_info    ),
                .custom_traffic_t (custom_traffic_t),
                .custom_traffic_en(custom_traffic_en)
        );
 
        pck_size_gen #(
                .NOC_ID(NOC_ID),
                .MIN(MIN_PACKET_SIZE),
                .MAX(MAX_PACKET_SIZE),
                .PCK_SIZ_SEL(PCK_SIZ_SEL),
                .DISCRETE_PCK_SIZ_NUM(DISCRETE_PCK_SIZ_NUM)
        )
        unicast_pck_size
        (
                .reset(reset),
                .clk(clk),
                .en(en),
                .pck_size(pck_size_uni) ,
                .rnd_discrete(rnd_discrete)
        );
 
 
        generate
        if(CAST_TYPE == "UNICAST") begin :uni
                assign dest_e_addr =    unicast_dest_e_addr;
                assign pck_size_o  =   pck_size_uni;
        end else begin :multi
                reg [DAw-1      :   0] multicast_dest_e_addr,temp;
                reg [6: 0] rnd_reg;
                wire [PCK_SIZw-1 : 0] pck_size_mcast;
                reg  [PCK_SIZw-1 : 0] pck_siz_tmp;
                wire [NEw-1 : 0] unicast_id_num;
 
 
                endp_addr_decoder  #(
                        .T1(T1),
                        .T2(T2),
                        .T3(T3),
                        .NE(NE),
                        .EAw(EAw),
                        .TOPOLOGY(TOPOLOGY)
                ) enc (
                        .code(unicast_dest_e_addr),
                        .id(unicast_id_num)
                );
 
 
                pck_size_gen #(
                        .NOC_ID(NOC_ID),
                        .PCK_SIZw(PCK_SIZw),
                        .MIN(MCAST_PCK_SIZ_MIN),
                        .MAX(MCAST_PCK_SIZ_MAX),
                        .PCK_SIZ_SEL("random-range"),
                        .DISCRETE_PCK_SIZ_NUM(DISCRETE_PCK_SIZ_NUM)
                ) mcast_pck_size (
                        .reset(reset),
                        .clk(clk),
                        .en(en),
                        .pck_size(pck_size_mcast) ,
                        .rnd_discrete(rnd_discrete)
                );
 
                always @(posedge clk ) begin
                        if(en | reset) begin
                                rnd_reg <=     $urandom_range(99,0);
                        end
                end
 
                if(CAST_TYPE == "MULTICAST_FULL") begin :mful
 
                        always @( * ) begin
                                multicast_dest_e_addr = {DAw{1'b0}};
                                temp={DAw{1'b0}};
                                temp[unicast_id_num]=1'b1;
                                pck_siz_tmp= pck_size_uni;
                                if(rnd_reg >= MCAST_TRAFFIC_RATIO) begin
                                        multicast_dest_e_addr[unicast_id_num]=1'b1;
                                end
                                else begin
                                        multicast_dest_e_addr =  $urandom();
                                        pck_siz_tmp=pck_size_mcast;
                                end
                                if(SELF_LOOP_EN == "NO") multicast_dest_e_addr[core_num]=1'b0;
                        end
 
 
 
                        assign dest_e_addr = (multicast_dest_e_addr=={DAw{1'b0}} )? temp : multicast_dest_e_addr ;
                        assign pck_size_o = pck_siz_tmp;
 
                end else if(CAST_TYPE == "MULTICAST_PARTIAL") begin :mpar
 
                        always @( * ) begin
                                multicast_dest_e_addr = {DAw{1'b0}};
                                temp={unicast_dest_e_addr,1'b1};
                                pck_siz_tmp= pck_size_uni;
                                if(rnd_reg >= MCAST_TRAFFIC_RATIO) begin
                                        multicast_dest_e_addr = {unicast_dest_e_addr,1'b1};
                                end
                                else begin
                                        multicast_dest_e_addr =  $urandom();
                                        multicast_dest_e_addr[0] =1'b0;
                                        pck_siz_tmp=pck_size_mcast;
                                        if(SELF_LOOP_EN == "NO") begin
                                                if(MCAST_ENDP_LIST[core_num]==1'b1) multicast_dest_e_addr[endp_id_to_mcast_id(core_num)+1]=1'b0;
                                        end
                                end
                        end
 
                        assign dest_e_addr = (multicast_dest_e_addr=={DAw{1'b0}} )? temp : multicast_dest_e_addr ;
                        assign pck_size_o = pck_siz_tmp;
 
 
 
                end else begin //Broadcast
 
                        always @( * ) begin
                                multicast_dest_e_addr = {DAw{1'b0}};
                                pck_siz_tmp = pck_size_uni;
                                if(rnd_reg >= MCAST_TRAFFIC_RATIO) begin
                                        multicast_dest_e_addr = {unicast_dest_e_addr,1'b1};
                                end
                                else begin
                                        pck_siz_tmp=pck_size_mcast;
                                end
                        end
                        assign dest_e_addr =  multicast_dest_e_addr ;
                        assign pck_size_o = pck_siz_tmp;
 
 
                end
 
        end endgenerate
 
endmodule
 
 
module  pck_dst_gen_unicast
#(
    parameter NOC_ID=0,
        parameter TRAFFIC =   "RANDOM",
    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
);
 
    `NOC_CONF
    localparam      ADDR_DIMENSION =   (TOPOLOGY ==    "MESH" || TOPOLOGY ==  "TORUS") ? 2 : 1;  // "RING" and FULLY_CONNECT
 
 
    localparam  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 #(
                        .NOC_ID(NOC_ID),
                .TRAFFIC(TRAFFIC),
                .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 #(
                .NOC_ID(NOC_ID),
                        .TRAFFIC(TRAFFIC),
                .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
#(
    parameter NOC_ID=0,
        parameter TRAFFIC =   "RANDOM",
    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
);
 
    `NOC_CONF
 
 
 
 
    localparam  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 [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 | `pronoc_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  #(
                        .NOC_ID(NOC_ID),
                .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
#(
        parameter NOC_ID=0,
        parameter TRAFFIC =   "RANDOM",
        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
);
 
    `NOC_CONF
 
 
    localparam
        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 | `pronoc_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  #(
                .NOC_ID(NOC_ID),
                        .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
#(
    parameter NOC_ID=0,
        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
);
 
        `NOC_CONF
 
        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(`pronoc_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(`pronoc_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
#(
   parameter NOC_ID=0,
   parameter HOTSPOT_NUM=2
) (
   clk,
   reset,
   en,
   hotspot_info,
   core_num,
   dest_ip_num,
   off_flag
);
 
   `NOC_CONF
 
        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 | `pronoc_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

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	56	alirezamon	`include "pronoc_def.v"
10	48	alirezamon
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	56	alirezamon	if(en \| `pronoc_reset) begin
56	48	alirezamon	`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	54	alirezamon	`module pck_dst_gen`
77	56	alirezamon	`#(`
78			`parameter NOC_ID=0,`
79			`parameter TRAFFIC = "RANDOM",`
80	54	alirezamon	`parameter HOTSPOT_NODE_NUM = 4,`
81			`parameter MCAST_TRAFFIC_RATIO =50,`
82			`parameter MCAST_PCK_SIZ_MIN = 2,`
83			`parameter MCAST_PCK_SIZ_MAX = 4,`
84			`parameter MIN_PACKET_SIZE=5,`
85			`parameter MAX_PACKET_SIZE=5,`
86			`parameter PCK_SIZ_SEL="random-discrete",`
87			`parameter DISCRETE_PCK_SIZ_NUM=1`
88
89			`)(`
90			`en,`
91			`current_e_addr,`
92			`core_num,`
93			`pck_number,`
94			`dest_e_addr,`
95			`clk,`
96			`reset,`
97			`valid_dst,`
98			`hotspot_info,`
99			`custom_traffic_t,`
100			`custom_traffic_en,`
101			`pck_size_o,`
102			`rnd_discrete`
103
104
105			`);`
106	48	alirezamon
107	56	alirezamon	`NOC_CONF
108	48	alirezamon
109	54	alirezamon	`localparam ADDR_DIMENSION = (TOPOLOGY == "MESH" \|\| TOPOLOGY == "TORUS") ? 2 : 1; // "RING" and FULLY_CONNECT`
110
111
112
113
114	56	alirezamon	`localparam PCK_CNTw = log2(MAX_PCK_NUM+1),`
115	54	alirezamon	`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 [DAw-1 : 0] dest_e_addr;`
122			`output valid_dst;`
123			`input [NEw-1 : 0] custom_traffic_t;`
124			`input custom_traffic_en;`
125
126
127			`output [PCK_SIZw-1:0] pck_size_o;`
128			`input rnd_discrete_t rnd_discrete [DISCRETE_PCK_SIZ_NUM-1: 0];`
129
130			`input hotspot_t hotspot_info [HOTSPOT_NUM-1 : 0];`
131
132
133			`wire [EAw-1 : 0] unicast_dest_e_addr;`
134			`wire [PCK_SIZw-1 : 0] pck_size_uni;`
135
136			`pck_dst_gen_unicast #(`
137	56	alirezamon	`.NOC_ID(NOC_ID),`
138	54	alirezamon	`.TRAFFIC(TRAFFIC),`
139			`.HOTSPOT_NODE_NUM(HOTSPOT_NODE_NUM)`
140			`)`
141			`unicast`
142			`(`
143			`.en (en ),`
144			`.current_e_addr (current_e_addr ),`
145			`.core_num (core_num ),`
146			`.pck_number (pck_number ),`
147			`.dest_e_addr (unicast_dest_e_addr),`
148			`.clk (clk ),`
149			`.reset (reset ),`
150			`.valid_dst (valid_dst ),`
151			`.hotspot_info (hotspot_info ),`
152			`.custom_traffic_t (custom_traffic_t),`
153			`.custom_traffic_en(custom_traffic_en)`
154			`);`
155
156			`pck_size_gen #(`
157	56	alirezamon	`.NOC_ID(NOC_ID),`
158	54	alirezamon	`.MIN(MIN_PACKET_SIZE),`
159			`.MAX(MAX_PACKET_SIZE),`
160			`.PCK_SIZ_SEL(PCK_SIZ_SEL),`
161			`.DISCRETE_PCK_SIZ_NUM(DISCRETE_PCK_SIZ_NUM)`
162			`)`
163			`unicast_pck_size`
164			`(`
165			`.reset(reset),`
166			`.clk(clk),`
167			`.en(en),`
168			`.pck_size(pck_size_uni) ,`
169			`.rnd_discrete(rnd_discrete)`
170	56	alirezamon	`);`
171	54	alirezamon
172
173			`generate`
174			`if(CAST_TYPE == "UNICAST") begin :uni`
175			`assign dest_e_addr = unicast_dest_e_addr;`
176			`assign pck_size_o = pck_size_uni;`
177			`end else begin :multi`
178			`reg [DAw-1 : 0] multicast_dest_e_addr,temp;`
179			`reg [6: 0] rnd_reg;`
180			`wire [PCK_SIZw-1 : 0] pck_size_mcast;`
181			`reg [PCK_SIZw-1 : 0] pck_siz_tmp;`
182			`wire [NEw-1 : 0] unicast_id_num;`
183
184
185			`endp_addr_decoder #(`
186	56	alirezamon	`.T1(T1),`
187			`.T2(T2),`
188			`.T3(T3),`
189			`.NE(NE),`
190			`.EAw(EAw),`
191			`.TOPOLOGY(TOPOLOGY)`
192			`) enc (`
193			`.code(unicast_dest_e_addr),`
194			`.id(unicast_id_num)`
195			`);`
196	54	alirezamon
197
198			`pck_size_gen #(`
199	56	alirezamon	`.NOC_ID(NOC_ID),`
200	54	alirezamon	`.PCK_SIZw(PCK_SIZw),`
201			`.MIN(MCAST_PCK_SIZ_MIN),`
202			`.MAX(MCAST_PCK_SIZ_MAX),`
203			`.PCK_SIZ_SEL("random-range"),`
204			`.DISCRETE_PCK_SIZ_NUM(DISCRETE_PCK_SIZ_NUM)`
205	56	alirezamon	`) mcast_pck_size (`
206	54	alirezamon	`.reset(reset),`
207			`.clk(clk),`
208			`.en(en),`
209			`.pck_size(pck_size_mcast) ,`
210			`.rnd_discrete(rnd_discrete)`
211	56	alirezamon	`);`
212	54	alirezamon
213			`always @(posedge clk ) begin`
214			`if(en \| reset) begin`
215			`rnd_reg <= $urandom_range(99,0);`
216			`end`
217			`end`
218
219			`if(CAST_TYPE == "MULTICAST_FULL") begin :mful`
220
221			`always @( * ) begin`
222			`multicast_dest_e_addr = {DAw{1'b0}};`
223			`temp={DAw{1'b0}};`
224			`temp[unicast_id_num]=1'b1;`
225			`pck_siz_tmp= pck_size_uni;`
226			`if(rnd_reg >= MCAST_TRAFFIC_RATIO) begin`
227			`multicast_dest_e_addr[unicast_id_num]=1'b1;`
228			`end`
229			`else begin`
230			`multicast_dest_e_addr = $urandom();`
231			`pck_siz_tmp=pck_size_mcast;`
232			`end`
233			`if(SELF_LOOP_EN == "NO") multicast_dest_e_addr[core_num]=1'b0;`
234			`end`
235
236
237
238			`assign dest_e_addr = (multicast_dest_e_addr=={DAw{1'b0}} )? temp : multicast_dest_e_addr ;`
239			`assign pck_size_o = pck_siz_tmp;`
240
241			`end else if(CAST_TYPE == "MULTICAST_PARTIAL") begin :mpar`
242
243			`always @( * ) begin`
244			`multicast_dest_e_addr = {DAw{1'b0}};`
245			`temp={unicast_dest_e_addr,1'b1};`
246			`pck_siz_tmp= pck_size_uni;`
247			`if(rnd_reg >= MCAST_TRAFFIC_RATIO) begin`
248			`multicast_dest_e_addr = {unicast_dest_e_addr,1'b1};`
249			`end`
250			`else begin`
251			`multicast_dest_e_addr = $urandom();`
252			`multicast_dest_e_addr[0] =1'b0;`
253			`pck_siz_tmp=pck_size_mcast;`
254			`if(SELF_LOOP_EN == "NO") begin`
255			`if(MCAST_ENDP_LIST[core_num]==1'b1) multicast_dest_e_addr[endp_id_to_mcast_id(core_num)+1]=1'b0;`
256			`end`
257			`end`
258			`end`
259
260			`assign dest_e_addr = (multicast_dest_e_addr=={DAw{1'b0}} )? temp : multicast_dest_e_addr ;`
261			`assign pck_size_o = pck_siz_tmp;`
262
263
264
265			`end else begin //Broadcast`
266
267			`always @( * ) begin`
268			`multicast_dest_e_addr = {DAw{1'b0}};`
269			`pck_siz_tmp = pck_size_uni;`
270			`if(rnd_reg >= MCAST_TRAFFIC_RATIO) begin`
271			`multicast_dest_e_addr = {unicast_dest_e_addr,1'b1};`
272			`end`
273			`else begin`
274			`pck_siz_tmp=pck_size_mcast;`
275			`end`
276			`end`
277			`assign dest_e_addr = multicast_dest_e_addr ;`
278			`assign pck_size_o = pck_siz_tmp;`
279
280
281			`end`
282
283			`end endgenerate`
284
285			`endmodule`
286
287
288			`module pck_dst_gen_unicast`
289	56	alirezamon	`#(`
290			`parameter NOC_ID=0,`
291			`parameter TRAFFIC = "RANDOM",`
292	48	alirezamon	`parameter HOTSPOT_NODE_NUM = 4`
293			`)(`
294			`en,`
295			`current_e_addr,`
296			`core_num,`
297			`pck_number,`
298			`dest_e_addr,`
299			`clk,`
300			`reset,`
301			`valid_dst,`
302			`hotspot_info,`
303			`custom_traffic_t,`
304			`custom_traffic_en`
305			`);`
306
307	56	alirezamon	`NOC_CONF
308	48	alirezamon	`localparam ADDR_DIMENSION = (TOPOLOGY == "MESH" \|\| TOPOLOGY == "TORUS") ? 2 : 1; // "RING" and FULLY_CONNECT`
309	56	alirezamon
310	48	alirezamon
311	56	alirezamon	`localparam PCK_CNTw = log2(MAX_PCK_NUM+1),`
312	48	alirezamon	`HOTSPOT_NUM= (TRAFFIC=="HOTSPOT")? HOTSPOT_NODE_NUM : 1;`
313
314			`input reset,clk,en;`
315			`input [NEw-1 : 0] core_num;`
316			`input [PCK_CNTw-1 : 0] pck_number;`
317			`input [EAw-1 : 0] current_e_addr;`
318			`output [EAw-1 : 0] dest_e_addr;`
319			`output valid_dst;`
320			`input [NEw-1 : 0] custom_traffic_t;`
321			`input custom_traffic_en;`
322
323			`input hotspot_t hotspot_info [HOTSPOT_NUM-1 : 0];`
324
325
326	56	alirezamon	`generate`
327			`if ( ADDR_DIMENSION == 2) begin :two_dim`
328	48	alirezamon
329			`two_dimension_pck_dst_gen #(`
330	56	alirezamon	`.NOC_ID(NOC_ID),`
331	48	alirezamon	`.TRAFFIC(TRAFFIC),`
332			`.HOTSPOT_NODE_NUM(HOTSPOT_NODE_NUM)`
333
334			`)`
335			`the_two_dimension_pck_dst_gen`
336			`(`
337			`.reset(reset),`
338			`.clk(clk),`
339			`.en(en),`
340			`.core_num(core_num),`
341			`.pck_number(pck_number),`
342			`.current_e_addr(current_e_addr),`
343			`.dest_e_addr(dest_e_addr),`
344			`.valid_dst(valid_dst),`
345			`.hotspot_info(hotspot_info),`
346			`.custom_traffic_t(custom_traffic_t),`
347			`.custom_traffic_en(custom_traffic_en)`
348			`);`
349
350	56	alirezamon	`end else begin : one_dim`
351	48	alirezamon
352			`one_dimension_pck_dst_gen #(`
353	56	alirezamon	`.NOC_ID(NOC_ID),`
354			`.TRAFFIC(TRAFFIC),`
355			`.HOTSPOT_NODE_NUM(HOTSPOT_NODE_NUM)`
356	48	alirezamon	`)`
357			`the_one_dimension_pck_dst_gen`
358			`(`
359			`.reset(reset),`
360			`.clk(clk),`
361			`.en(en),`
362			`.core_num(core_num),`
363			`.pck_number(pck_number),`
364			`.current_e_addr(current_e_addr),`
365			`.dest_e_addr(dest_e_addr),`
366			`.valid_dst(valid_dst),`
367			`.hotspot_info(hotspot_info),`
368			`.custom_traffic_t(custom_traffic_t),`
369			`.custom_traffic_en(custom_traffic_en)`
370			`);`
371
372	56	alirezamon	`end`
373			`endgenerate`
374			`endmodule`
375	48	alirezamon
376
377
378
379			`module two_dimension_pck_dst_gen`
380	56	alirezamon	`#(`
381			`parameter NOC_ID=0,`
382			`parameter TRAFFIC = "RANDOM",`
383			`parameter HOTSPOT_NODE_NUM = 4`
384	48	alirezamon
385			`)(`
386			`en,`
387			`current_e_addr,`
388			`dest_e_addr,`
389			`core_num,`
390			`pck_number,`
391			`clk,`
392			`reset,`
393			`valid_dst,`
394			`hotspot_info,`
395	56	alirezamon	`custom_traffic_t,`
396			`custom_traffic_en`
397	48	alirezamon	`);`
398
399	56	alirezamon	`NOC_CONF
400
401	48	alirezamon
402
403
404	56	alirezamon	`localparam PCK_CNTw = log2(MAX_PCK_NUM+1),`
405	48	alirezamon	`HOTSPOT_NUM= (TRAFFIC=="HOTSPOT")? HOTSPOT_NODE_NUM : 1;`
406
407			`input reset,clk,en;`
408			`input [NEw-1 : 0] core_num;`
409			`input [PCK_CNTw-1 : 0] pck_number;`
410			`input [EAw-1 : 0] current_e_addr;`
411			`output [EAw-1 : 0] dest_e_addr;`
412			`output valid_dst;`
413			`input hotspot_t hotspot_info [HOTSPOT_NUM-1 : 0];`
414			`input [NEw-1 : 0] custom_traffic_t;`
415			`input custom_traffic_en;`
416
417	56	alirezamon
418	48	alirezamon
419			`wire [NXw-1 : 0] current_x;`
420			`wire [NYw-1 : 0] current_y;`
421			`wire [NLw-1 : 0] current_l;`
422			`wire [NXw-1 : 0] dest_x;`
423			`wire [NYw-1 : 0] dest_y;`
424			`wire [NLw-1 : 0] dest_l;`
425
426			`mesh_tori_endp_addr_decode #(`
427			`.TOPOLOGY(TOPOLOGY),`
428			`.T1(T1),`
429			`.T2(T2),`
430			`.T3(T3),`
431			`.EAw(EAw)`
432			`)`
433			`src_addr_decode`
434			`(`
435			`.e_addr(current_e_addr),`
436			`.ex(current_x),`
437			`.ey(current_y),`
438			`.el(current_l),`
439			`.valid( )`
440			`);`
441
442			`wire off_flag;`
443
444
445
446
447
448			`wire [NEw-1 : 0] dest_ip_num;`
449			`genvar i;`
450
451			`generate`
452			`if (TRAFFIC == "RANDOM") begin`
453
454			`logic [6 : 0] rnd_reg;`
455
456			`always @(posedge clk ) begin`
457	56	alirezamon	if(en \| `pronoc_reset) begin
458	48	alirezamon	`rnd_reg = $urandom_range(NE-1,0);`
459			`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`
460
461			`end`
462			`end`
463			`assign dest_ip_num = rnd_reg;`
464
465			`endp_addr_encoder #(`
466			`.T1(T1),`
467			`.T2(T2),`
468			`.T3(T3),`
469			`.NE(NE),`
470			`.EAw(EAw),`
471			`.TOPOLOGY(TOPOLOGY)`
472			`)`
473			`addr_encoder`
474			`(`
475			`.id(dest_ip_num),`
476			`.code(dest_e_addr)`
477			`);`
478
479			`end else if (TRAFFIC == "HOTSPOT") begin`
480
481			`hot_spot_dest_gen #(`
482	56	alirezamon	`.NOC_ID(NOC_ID),`
483			`.HOTSPOT_NUM(HOTSPOT_NUM),`
484			`.NE(NE),`
485			`.NEw(NEw)`
486			`) hspot (`
487			`.reset(reset),`
488			`.clk(clk),`
489			`.en(en),`
490			`.hotspot_info(hotspot_info),`
491			`.dest_ip_num (dest_ip_num),`
492			`.core_num(core_num),`
493			`.off_flag(off_flag)`
494			`);`
495	48	alirezamon
496			`endp_addr_encoder #(`
497			`.T1(T1),`
498			`.T2(T2),`
499			`.T3(T3),`
500			`.NE(NE),`

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 56