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_noc/] [packet_injector.sv] - Blame information for rev 56

Details | Compare with Previous | View Log


`include "pronoc_def.v"
 
/****************************
 * This module can inject and eject packets from the NoC.
 * It can be used in simulation for injecting real application traces to the NoC
 * *************************/
 
 
module packet_injector #(
        parameter NOC_ID=0
) (
        //general
        current_e_addr,
        reset,
        clk,
        //noc port
        chan_in,
        chan_out,
        //control interafce
        pck_injct_in,
        pck_injct_out
);
 
        `NOC_CONF
 
        //general
        input reset,clk;
        input [EAw-1 :0 ] current_e_addr;
 
        // the destination endpoint address
        //NoC interface
        input   smartflit_chanel_t      chan_in;
        output  smartflit_chanel_t      chan_out;
        //control interafce
 
        input   pck_injct_t pck_injct_in;
        output  pck_injct_t pck_injct_out;
 
 
        wire  [RAw-1 :0 ] current_r_addr;
 
        wire  [DSTPw-1 : 0 ] destport;
        reg flit_wr;
 
 
 
 
 
 
        assign current_r_addr = chan_in.ctrl_chanel.neighbors_r_addr;
 
 
        generate if(CAST_TYPE == "UNICAST") begin : uni
 
                        conventional_routing #(
                                        .NOC_ID(NOC_ID),
                                        .TOPOLOGY(TOPOLOGY),
                                        .ROUTE_NAME(ROUTE_NAME),
                                        .ROUTE_TYPE(ROUTE_TYPE),
                                        .T1(T1),
                                        .T2(T2),
                                        .T3(T3),
                                        .RAw(RAw),
                                        .EAw(EAw),
                                        .DSTPw(DSTPw),
                                        .LOCATED_IN_NI(1)
                                )
                                routing_module
                                (
                                        .reset(reset),
                                        .clk(clk),
                                        .current_r_addr(current_r_addr),
                                        .dest_e_addr(pck_injct_in.endp_addr),
                                        .src_e_addr(current_e_addr),
                                        .destport(destport)
                                );
                end endgenerate
 
 
        localparam
                HDR_BYTE_NUM =  HDR_MAX_DATw / 8, // = HDR_MAX_DATw / (8 - HDR_MAX_DATw %8)
                HDR_DATA_w_tmp   =  HDR_BYTE_NUM * 8,
                HDR_DATA_w =
                (PCK_INJ_Dw < HDR_DATA_w_tmp)? PCK_INJ_Dw :
                (HDR_DATA_w_tmp==0)? 1: HDR_DATA_w_tmp;
 
        wire [HDR_DATA_w-1 : 0] hdr_data_in = pck_injct_in.data [HDR_DATA_w-1 : 0];
        wire [Fw-1 : 0] hdr_flit_out;
 
        header_flit_generator #(
                .NOC_ID(NOC_ID),
                .DATA_w(HDR_DATA_w)
        ) the_header_flit_generator (
                .flit_out                       (hdr_flit_out),
                .vc_num_in                      (pck_injct_in.vc),
                .class_in                       (pck_injct_in.class_num),
                .dest_e_addr_in         (pck_injct_in.endp_addr),
                .src_e_addr_in          (current_e_addr),
                .weight_in                      (pck_injct_in.init_weight),
                .destport_in            (destport),
                .data_in                        (hdr_data_in),
                .be_in({BEw{1'b1}} )// Be is not used in simulation as we dont sent real data
        );
 
 
        localparam
                REMAIN_DATw =  PCK_INJ_Dw - HDR_DATA_w,
                REMAIN_DAT_FLIT_I = (REMAIN_DATw / Fpay),
                REMAIN_DAT_FLIT_F = (REMAIN_DATw % Fpay == 0)? 0 : 1,
                REMAIN_DAT_FLIT   = REMAIN_DAT_FLIT_I + REMAIN_DAT_FLIT_F,
                CNTw = log2(REMAIN_DAT_FLIT),
                MIN_PCK_SIZ = REMAIN_DAT_FLIT +1;
 
 
        logic [PCK_SIZw-1             :   0]  counter, counter_next;
        logic [CNTw-1                 :   0]  counter2,counter2_next;
        reg tail,head;
 
        wire [Fpay -1 : 0]  remain_dat [REMAIN_DAT_FLIT -1 : 0];
        wire [Fpay-1 : 0] dataIn =  remain_dat[counter2];
        enum  bit [2:0] {HEADER, BODY,TAIL} flit_type,flit_type_next;
 
 
 
        wire [V-1 : 0]   wr_vc_send = (flit_wr)?   pck_injct_in.vc : {V{1'b0}};
        wire [V-1 : 0]   vc_fifo_full;
 
 
        wire noc_ready;
 
        localparam
                LAST_TMP =PCK_INJ_Dw -  (Fpay*REMAIN_DAT_FLIT_I)-HDR_DATA_w,
                LASTw=(LAST_TMP==0)? Fpay : LAST_TMP;
        genvar i;
        generate
                for(i=0; i
                        assign remain_dat [i] = pck_injct_in.data [Fpay*(i+1)+HDR_DATA_w-1   : (Fpay*i)+HDR_DATA_w];
                end
                if(REMAIN_DAT_FLIT_F ) begin :flt
 
                        assign remain_dat [REMAIN_DAT_FLIT_I][LASTw-1 : 0] = pck_injct_in.data [PCK_INJ_Dw-1   : (Fpay*REMAIN_DAT_FLIT_I)+HDR_DATA_w];
                end
        endgenerate
 
 
 
 
 
        one_hot_mux #(
                        .IN_WIDTH   (V ),
                        .SEL_WIDTH  (V ),
                        .OUT_WIDTH  (1 )
                ) one_hot_mux1 (
                        .mux_in     (~ vc_fifo_full    ),
                        .mux_out    (noc_ready   ),
                        .sel        (pck_injct_in.vc       ));
 
 
 
 
        always @ (*) begin
                counter_next = counter;
                counter2_next =counter2;
                flit_type_next =flit_type;
                tail=1'b0;
                head=1'b0;
                flit_wr=0;
                if(noc_ready)begin
                        case(flit_type)
                                HEADER:begin
                                        if(pck_injct_in.pck_wr)begin
                                                flit_wr=1;
                                                counter_next = pck_injct_in.size-1;
                                                counter2_next=0;
                                                head=1'b1;
                                                if(pck_injct_in.size == 1)begin
                                                        tail=1'b1;
                                                end else if (pck_injct_in.size == 2) begin
                                                        flit_type_next = TAIL;
                                                end else begin
                                                        flit_type_next = BODY;
                                                end
                                        end
                                end
                                BODY: begin
                                        flit_wr=1;
                                        counter_next = counter -1'b1;
                                        counter2_next =counter2 +1'b1;
                                        if(counter == 2) begin
                                                flit_type_next = TAIL;
                                        end
                                end
                                TAIL: begin
                                        flit_type_next = HEADER;
                                        flit_wr=1;
                                        tail=1'b1;
                                end
                                default: begin
 
                                end
                        endcase
 
                end
        end
 
        logic [V-1 : 0] credit_o, credit_o_next;
 
        //pronoc_register #(.W(3),.RESET_TO(HEADER) ) reg1 (.in(flit_type_next ), .out(flit_type), .reset(reset), .clk(clk));
        pronoc_register #(.W(PCK_SIZw)) reg2 (.in(counter_next ), .out(counter), .reset(reset), .clk(clk));
        pronoc_register #(.W(CNTw))     reg3 (.in(counter2_next ), .out(counter2), .reset(reset), .clk(clk));
        pronoc_register #(.W(V))     reg4 (.in(credit_o_next ), .out(credit_o), .reset(reset), .clk(clk));
 
 
        always @ (*) begin
                credit_o_next = credit_o;
                if (chan_in.flit_chanel.flit_wr) credit_o_next =  chan_in.flit_chanel.flit.vc;
                else credit_o_next = {V{1'b0}};
        end
 
        always @(`pronoc_clk_reset_edge)begin
                if(`pronoc_reset) flit_type<=HEADER;
                else flit_type <= flit_type_next;
        end
 
 
 
        injector_ovc_status #(
                        .V(V),
                        .B(LB),
                        .CRDTw(CRDTw)
                )
                the_ovc_status
                (
                        .credit_init_val_in ( chan_in.ctrl_chanel.credit_init_val),
                        .wr_in(wr_vc_send),
                        .credit_in(chan_in.flit_chanel.credit),
                        .full_vc(vc_fifo_full),
                        .nearly_full_vc( ),
                        .empty_vc( ),
                        .clk(clk),
                        .reset(reset)
                );
 
        wire [HDR_DATA_w-1 : 0] hdr_data_o;
        hdr_flit_t hdr_flit_i;
 
        header_flit_info  #(
                .NOC_ID (NOC_ID),
                .DATA_w (HDR_DATA_w)
        ) extractor (
                .flit(chan_in.flit_chanel.flit),
                .hdr_flit(hdr_flit_i),
                .data_o(hdr_data_o)
        );
 
        wire [PCK_INJ_Dw-1 : 0]  pck_data_o [V-1 : 0];
        reg  [Fpay-1 : 0] pck_data_o_gen [V-1 : 0][REMAIN_DAT_FLIT : 0];
 
        genvar k;
 
        reg [PCK_SIZw-1 : 0] rsv_counter [V-1 : 0];
        reg [EAw-1 : 0] sender_endp_addr_reg [V-1 : 0];
        logic [15:0] h2t_counter [V-1 : 0];
        logic [15:0] h2t_counter_next [V-1 : 0];
 
        //synthesis translate_off
        wire [NEw-1 : 0] current_id;
        wire [NEw-1 : 0] sendor_id;
        endp_addr_decoder #( .TOPOLOGY(TOPOLOGY), .T1(T1), .T2(T2), .T3(T3), .EAw(EAw),  .NE(NE)) encode1 ( .id(current_id), .code(current_e_addr));
        endp_addr_decoder #( .TOPOLOGY(TOPOLOGY), .T1(T1), .T2(T2), .T3(T3), .EAw(EAw),  .NE(NE)) encode2 ( .id(sendor_id), .code(pck_injct_out.endp_addr[EAw-1 : 0]));
        //synthesis translate_on
 
        wire [NE-1 :0] dest_mcast_all_endp;
 
 
 
 
        generate
                if(CAST_TYPE != "UNICAST") begin
                        mcast_dest_list_decode #(
                                .NOC_ID(NOC_ID)
                        ) decode (
                                .dest_e_addr(hdr_flit_i.dest_e_addr),
                                .dest_o(dest_mcast_all_endp),
                                .row_has_any_dest(),
                                .is_unicast()
                        );
                end
 
                for(i=0; i
                        always@(*) begin
                                h2t_counter_next[i]=h2t_counter[i]+1'b1;
                                if(chan_in.flit_chanel.flit.vc[i] & chan_in.flit_chanel.flit_wr & chan_in.flit_chanel.flit.hdr_flag)begin
                                        h2t_counter_next[i]= 16'd0; // reset once header flit is received
                                end//hdr flit wr
                        end//always
 
 
 
 
                        always @ (`pronoc_clk_reset_edge )begin
                                if(`pronoc_reset)  begin
                                        rsv_counter[i]<= {PCK_SIZw{1'b0}};
                                        h2t_counter[i]<= 16'd0;
                                        sender_endp_addr_reg [i]<= {EAw{1'b0}};
                                end else begin
                                        h2t_counter[i]<=h2t_counter_next[i];
                                        if(chan_in.flit_chanel.flit.vc[i] & chan_in.flit_chanel.flit_wr ) begin
                                                if(chan_in.flit_chanel.flit.hdr_flag)begin
                                                        rsv_counter[i]<= {{(PCK_SIZw-1){1'b0}}, 1'b1};
                                                        sender_endp_addr_reg [i]<= hdr_flit_i.src_e_addr;
                                                        //synthesis translate_off
                                                        if(CAST_TYPE == "UNICAST") begin
                                                                if(hdr_flit_i.dest_e_addr[EAw-1:0] != current_e_addr) begin
                                                                        $display("%t: ERROR: packet destination address %d does not match receiver endp address %d. %m",$time,hdr_flit_i.dest_e_addr , current_e_addr );
                                                                        $finish;
                                                                end//if hdr_flit_i
                                                        end else begin
                                                                if(dest_mcast_all_endp[current_id] !=1'b1 ) begin
                                                                        $display("%t: ERROR: packet destination address %b does not match receiver endp address %d. %m",$time,hdr_flit_i.dest_e_addr , current_e_addr ,current_id );
                                                                        $finish;
                                                                end
                                                        end//if hdr_flit_i
                                                        //synthesis translate_on
                                                end //if hdr_flag
                                                else rsv_counter[i]<= rsv_counter[i]+1'b1;
                                        end//flit wr
                                end//reset
                        end//always
 
 
 
 
                        for (k=0;k< REMAIN_DAT_FLIT+1;k++)begin : K_
 
                                always @ (`pronoc_clk_reset_edge )begin
                                        if(`pronoc_reset)  begin
                                                pck_data_o_gen [i][k] <= {Fpay{1'b0}};
 
                                        end else begin
                                                if(chan_in.flit_chanel.flit.vc[i] & chan_in.flit_chanel.flit_wr ) begin
                                                        if (chan_in.flit_chanel.flit.hdr_flag )begin
                                                                if ( k ==0 ) pck_data_o_gen [i][k][HDR_DATA_w-1 : 0] <= hdr_data_o;
                                                        end
                                                        else begin
                                                                if (rsv_counter[i] == k ) pck_data_o_gen [i][k] <= chan_in.flit_chanel.flit.payload[Fpay-1 : 0];
 
                                                        end // else
                                                end //if
                                        end //else
                                end// always
 
                                if   (k == 0 ) assign pck_data_o [i][HDR_DATA_w-1 : 0] = pck_data_o_gen [i][0][HDR_DATA_w-1 : 0];
                                else if (k == REMAIN_DAT_FLIT) assign pck_data_o [i][PCK_INJ_Dw-1 :    (k-1)*Fpay+ HDR_DATA_w] = pck_data_o_gen [i][k][LASTw-1: 0];
                                else assign pck_data_o [i][(k)*Fpay+HDR_DATA_w -1 : (k-1)*Fpay+ HDR_DATA_w] = pck_data_o_gen [i][k];
 
                        end //for k
 
 
                        //synthesis translate_off
                        always @(posedge clk) begin
                                if((pck_injct_out.ready[i] == 1'b0 ) & pck_injct_in.vc[i] & pck_injct_in.pck_wr )begin
                                        $display("%t: ERROR: a packet injection request is recived in core(%d), vc (%d) while packet injectore was not ready. %m",$time,current_id,i);
                                        $finish;
                                end
 
                        end
                        //synthesis translate_on
 
 
 
 
                end//for i
        endgenerate
 
        wire [V-1 : 0] vc_reg;
        wire tail_flag_reg, hdr_flag_reg;
 
 
        pronoc_register #(.W(V))   register1 (.in(chan_in.flit_chanel.flit.vc),        .reset  (reset ), .clk (clk),.out(vc_reg));
        pronoc_register #(.W(1))   register2 (.in(chan_in.flit_chanel.flit.hdr_flag),   .reset  (reset ), .clk (clk),.out(hdr_flag_reg));
        pronoc_register #(.W(1))   register3 (.in(chan_in.flit_chanel.flit.tail_flag & chan_in.flit_chanel.flit_wr ),.reset  (reset ), .clk (clk),.out(tail_flag_reg));
 
        wire [Vw-1 : 0] vc_bin;
 
        one_hot_to_bin #(
                        .ONE_HOT_WIDTH  (V),
                        .BIN_WIDTH      (Vw )
                ) one_hot_to_bin (
                        .one_hot_code   (vc_reg  ),
                        .bin_code       (vc_bin      )
                );
 
 
        assign pck_injct_out.data  =  pck_data_o[vc_bin];
        assign pck_injct_out.size  =  rsv_counter[vc_bin];
        assign pck_injct_out.h2t_delay = h2t_counter[vc_bin];
        assign pck_injct_out.ready = (flit_type == HEADER)?  ~vc_fifo_full : {V{1'b0}};
        assign pck_injct_out.endp_addr[EAw-1 : 0] =  sender_endp_addr_reg[vc_bin];
        assign pck_injct_out.vc = vc_reg;
        assign pck_injct_out.pck_wr = tail_flag_reg;
 
        assign chan_out.flit_chanel.flit.hdr_flag =head;
        assign chan_out.flit_chanel.flit.tail_flag=tail;
        assign chan_out.flit_chanel.flit.vc=pck_injct_in.vc;
        assign chan_out.flit_chanel.flit_wr=flit_wr;
 
        generate
        /* verilator lint_off WIDTH */
                if(PCK_TYPE == "SINGLE_FLIT" ) begin : single_f
                        /* verilator lint_on WIDTH */
                        assign chan_out.flit_chanel.flit.payload = hdr_flit_out[FPAYw-1 : 0];
                end else begin
                        assign chan_out.flit_chanel.flit.payload = (flit_type== HEADER)? hdr_flit_out[Fpay-1 : 0] : dataIn;
                end
        endgenerate
 
        assign chan_out.smart_chanel = {SMART_CHANEL_w{1'b0}};
        assign chan_out.flit_chanel.congestion = {CONGw{1'b0}};
        assign chan_out.flit_chanel.credit= credit_o;
        assign chan_out.ctrl_chanel.credit_init_val= LB;
        assign chan_out.ctrl_chanel.credit_release_en={V{1'b0}};
        assign chan_out.ctrl_chanel.endp_port =1'b1;
 
 
 
        distance_gen #(
                        .TOPOLOGY(TOPOLOGY),
                        .T1(T1),
                        .T2(T2),
                        .T3(T3),
                        .EAw(EAw),
                        .DISTw(DISTw)
                )
                the_distance_gen
                (
                        .src_e_addr(sender_endp_addr_reg[vc_bin]),
                        .dest_e_addr(current_e_addr),
                        .distance(pck_injct_out.distance)
                );
 
 
 
 
 
 
        //synthesis translate_off
        //`define MONITOR_RSV_DAT
 
 
 
        always @(posedge clk) begin
                if((pck_injct_in.vc == {V{1'b0}} ) & pck_injct_in.pck_wr )begin
                        $display("%t: ERROR: a packet injection request is recived while vc is not set. %m",$time);
                        $finish;
                end
                if(pck_injct_in.pck_wr && (pck_injct_in.size
                        $display("%t: ERROR: requested %d flit packet size is smaller than minimum %d flits to send %d bits of data. %m",$time,pck_injct_in.size,MIN_PCK_SIZ, PCK_INJ_Dw );
                        $finish;
                end
 
                `ifdef MONITOR_RSV_DAT
 
 
                        if(pck_injct_in.pck_wr) begin
                                $display ("pck_inj(%d) send a packet:  size=%d, data=%h, v=%h",current_id,
                                                pck_injct_in.size, pck_injct_in.data,pck_injct_in.vc);
                        end
 
                        if(pck_injct_out.pck_wr) begin
                                $display ("pck_inj(%d) got a packet: source=%d, size=%d, data=%h",current_id,
                                                sendor_id,pck_injct_out.size,pck_injct_out.data);
                        end
 
 
                `endif
 
        end
 
 
        //synthesis translate_on
 
 
 
 
 
endmodule
 
 
 
 
/******************
 *   ovc_status
 *******************/
 
module injector_ovc_status #(
                parameter V     =   4,
                parameter B =   16,
                parameter CRDTw =4
                )
                (
 
                input   [V-1 : 0] [CRDTw-1 : 0 ] credit_init_val_in,
                input   [V-1            :0] wr_in,
                input   [V-1            :0] credit_in,
                output  [V-1            :0] full_vc,
                output  [V-1            :0] nearly_full_vc,
                output  [V-1            :0] empty_vc,
                input                       clk,
                input                       reset
                );
 
 
        function integer log2;
                input integer number; begin
                        log2=(number <=1) ? 1: 0;
                        while(2**log2
                                log2=log2+1;
                        end
                end
        endfunction // log2
 
 
        localparam  DEPTH_WIDTH =   log2(B+1);
 
 
        reg  [DEPTH_WIDTH-1 : 0] credit    [V-1 : 0];
        wire  [V-1 : 0] cand_vc_next;
 
 
        genvar i;
        generate
                for(i=0;i
                        always @ (`pronoc_clk_reset_edge )begin
                                if(`pronoc_reset) begin
                                        credit[i]<= credit_init_val_in[i][DEPTH_WIDTH-1:0];
                                end else begin
                                        if(  wr_in[i]  && ~credit_in[i])   credit[i] <= credit[i]-1'b1;
                                        if( ~wr_in[i]  &&  credit_in[i])   credit[i] <= credit[i]+1'b1;
                                end //reset
                        end//always
 
                        assign  full_vc[i]   = (credit[i] == {DEPTH_WIDTH{1'b0}});
                        assign  nearly_full_vc[i]=  (credit[i] == 1) |  full_vc[i];
                        assign  empty_vc[i]  = (credit[i] == credit_init_val_in[i][DEPTH_WIDTH-1:0]);
                end//for
        endgenerate
endmodule
 
 
 
 
/**************************************
 *
 *
 * ***********************************/
 
 
 
module packet_injector_verilator #(
        parameter NOC_ID=0
) (
        //general
        current_e_addr,
        reset,
        clk,
        //noc port
        chan_in,
        chan_out,
        //control interafce
        pck_injct_in_data,
        pck_injct_in_size,
        pck_injct_in_endp_addr,
        pck_injct_in_class_num,
        pck_injct_in_init_weight,
        pck_injct_in_vc,
        pck_injct_in_pck_wr,
        pck_injct_in_ready,
 
        pck_injct_out_data,
        pck_injct_out_size,
        pck_injct_out_endp_addr,
        pck_injct_out_class_num,
        pck_injct_out_init_weight,
        pck_injct_out_vc,
        pck_injct_out_pck_wr,
        pck_injct_out_ready,
        pck_injct_out_distance,
        pck_injct_out_h2t_delay,
        min_pck_size
 
);
 
        `NOC_CONF
 
        //general
        input reset,clk;
        input [EAw-1 :0 ] current_e_addr;
 
        // the destination endpoint address
        //NoC interface
        input   smartflit_chanel_t      chan_in;
        output  smartflit_chanel_t      chan_out;
        //control interafce
 
 
        input [PCK_INJ_Dw-1 : 0] pck_injct_in_data;
        input [PCK_SIZw-1   : 0] pck_injct_in_size;
        input [DAw-1        : 0] pck_injct_in_endp_addr;
        input [Cw-1         : 0] pck_injct_in_class_num;
        input [WEIGHTw-1    : 0] pck_injct_in_init_weight;
        input [V-1          : 0] pck_injct_in_vc;
        input                    pck_injct_in_pck_wr;
        input [V-1          : 0] pck_injct_in_ready;
 
        output [PCK_INJ_Dw-1 : 0] pck_injct_out_data;
        output [PCK_SIZw-1   : 0] pck_injct_out_size;
        output [DAw-1        : 0] pck_injct_out_endp_addr;
        output [Cw-1         : 0] pck_injct_out_class_num;
        output [WEIGHTw-1    : 0] pck_injct_out_init_weight;
        output [V-1          : 0] pck_injct_out_vc;
        output                    pck_injct_out_pck_wr;
        output [V-1          : 0] pck_injct_out_ready;
        output [DISTw-1           : 0] pck_injct_out_distance;
        output [15                        : 0] pck_injct_out_h2t_delay;
        output [4                         : 0] min_pck_size;
 
        pck_injct_t pck_injct_in;
        pck_injct_t pck_injct_out;
 
        assign pck_injct_in.data         = pck_injct_in_data;
        assign pck_injct_in.size         = pck_injct_in_size;
        assign pck_injct_in.endp_addr    = pck_injct_in_endp_addr;
        assign pck_injct_in.class_num    = pck_injct_in_class_num;
        assign pck_injct_in.init_weight  = pck_injct_in_init_weight;
        assign pck_injct_in.vc           = pck_injct_in_vc;
        assign pck_injct_in.pck_wr        = pck_injct_in_pck_wr;
        assign pck_injct_in.ready        = pck_injct_in_ready;
 
        assign pck_injct_out_data        = pck_injct_out.data;
        assign pck_injct_out_size        = pck_injct_out.size;
        assign pck_injct_out_endp_addr   = pck_injct_out.endp_addr;
        assign pck_injct_out_class_num   = pck_injct_out.class_num;
        assign pck_injct_out_init_weight = pck_injct_out.init_weight;
        assign pck_injct_out_vc          = pck_injct_out.vc;
        assign pck_injct_out_pck_wr       = pck_injct_out.pck_wr;
        assign pck_injct_out_ready       = pck_injct_out.ready;
        assign pck_injct_out_distance    = pck_injct_out.distance;
        assign pck_injct_out_h2t_delay   = pck_injct_out.h2t_delay;
 
        packet_injector #(
                .NOC_ID(NOC_ID)
        ) injector (
                .current_e_addr  (current_e_addr ),
                .reset           (reset          ),
                .clk             (clk            ),
                .chan_in         (chan_in        ),
                .chan_out        (chan_out       ),
                .pck_injct_in    (pck_injct_in   ),
                .pck_injct_out   (pck_injct_out  )
        );
 
 
        localparam
                HDR_BYTE_NUM =  HDR_MAX_DATw / 8, // = HDR_MAX_DATw / (8 - HDR_MAX_DATw %8)
                HDR_DATA_w_tmp   =  HDR_BYTE_NUM * 8,
                HDR_DATA_w =
                (PCK_INJ_Dw < HDR_DATA_w_tmp)? PCK_INJ_Dw :
                (HDR_DATA_w_tmp==0)? 1: HDR_DATA_w_tmp,
                REMAIN_DATw =  PCK_INJ_Dw - HDR_DATA_w,
                REMAIN_DAT_FLIT_I = (REMAIN_DATw / Fpay),
                REMAIN_DAT_FLIT_F = (REMAIN_DATw % Fpay == 0)? 0 : 1,
                REMAIN_DAT_FLIT   = REMAIN_DAT_FLIT_I + REMAIN_DAT_FLIT_F,
                CNTw = log2(REMAIN_DAT_FLIT),
                MIN_PCK_SIZ = REMAIN_DAT_FLIT +1;
 
        assign  min_pck_size = MIN_PCK_SIZ[4:0];
 
 
        // `ifdef VERILATOR
        //      logic  endp_is_active   /*verilator public_flat_rd*/ ;
        //
        //      always @ (*) begin
        //              endp_is_active  = 1'b0;
        //              if (chan_out.flit_chanel.flit_wr) endp_is_active=1'b1;
        //              if (chan_out.flit_chanel.credit > {V{1'b0}} ) endp_is_active=1'b1;
        //              if (chan_out.smart_chanel.requests > {SMART_NUM{1'b0}} ) endp_is_active=1'b1;
        //      end
        // `endif
 
 
endmodule

Line No.	Rev	Author	Line
1	54	alirezamon	`include "pronoc_def.v"
2
3	48	alirezamon	`/****************************`
4			`* This module can inject and eject packets from the NoC.`
5			`* It can be used in simulation for injecting real application traces to the NoC`
6			`* *************************/`
7
8
9	56	alirezamon	`module packet_injector #(`
10			`parameter NOC_ID=0`
11			`) (`
12			`//general`
13			`current_e_addr,`
14			`reset,`
15			`clk,`
16			`//noc port`
17			`chan_in,`
18			`chan_out,`
19			`//control interafce`
20			`pck_injct_in,`
21			`pck_injct_out`
22			`);`
23	48	alirezamon
24	56	alirezamon	`NOC_CONF
25
26	48	alirezamon	`//general`
27			`input reset,clk;`
28			`input [EAw-1 :0 ] current_e_addr;`
29
30			`// the destination endpoint address`
31			`//NoC interface`
32			`input smartflit_chanel_t chan_in;`
33			`output smartflit_chanel_t chan_out;`
34			`//control interafce`
35
36			`input pck_injct_t pck_injct_in;`
37			`output pck_injct_t pck_injct_out;`
38
39
40			`wire [RAw-1 :0 ] current_r_addr;`
41
42			`wire [DSTPw-1 : 0 ] destport;`
43			`reg flit_wr;`
44
45
46
47
48
49
50			`assign current_r_addr = chan_in.ctrl_chanel.neighbors_r_addr;`
51
52
53	54	alirezamon	`generate if(CAST_TYPE == "UNICAST") begin : uni`
54	48	alirezamon
55	54	alirezamon	`conventional_routing #(`
56	56	alirezamon	`.NOC_ID(NOC_ID),`
57	54	alirezamon	`.TOPOLOGY(TOPOLOGY),`
58			`.ROUTE_NAME(ROUTE_NAME),`
59			`.ROUTE_TYPE(ROUTE_TYPE),`
60			`.T1(T1),`
61			`.T2(T2),`
62			`.T3(T3),`
63			`.RAw(RAw),`
64			`.EAw(EAw),`
65			`.DSTPw(DSTPw),`
66			`.LOCATED_IN_NI(1)`
67			`)`
68			`routing_module`
69			`(`
70			`.reset(reset),`
71			`.clk(clk),`
72			`.current_r_addr(current_r_addr),`
73			`.dest_e_addr(pck_injct_in.endp_addr),`
74			`.src_e_addr(current_e_addr),`
75			`.destport(destport)`
76			`);`
77			`end endgenerate`
78	48	alirezamon
79
80			`localparam`
81			`HDR_BYTE_NUM = HDR_MAX_DATw / 8, // = HDR_MAX_DATw / (8 - HDR_MAX_DATw %8)`
82			`HDR_DATA_w_tmp = HDR_BYTE_NUM * 8,`
83	54	alirezamon	`HDR_DATA_w =`
84			`(PCK_INJ_Dw < HDR_DATA_w_tmp)? PCK_INJ_Dw :`
85			`(HDR_DATA_w_tmp==0)? 1: HDR_DATA_w_tmp;`
86	48	alirezamon
87			`wire [HDR_DATA_w-1 : 0] hdr_data_in = pck_injct_in.data [HDR_DATA_w-1 : 0];`
88			`wire [Fw-1 : 0] hdr_flit_out;`
89
90			`header_flit_generator #(`
91	56	alirezamon	`.NOC_ID(NOC_ID),`
92			`.DATA_w(HDR_DATA_w)`
93			`) the_header_flit_generator (`
94			`.flit_out (hdr_flit_out),`
95			`.vc_num_in (pck_injct_in.vc),`
96			`.class_in (pck_injct_in.class_num),`
97			`.dest_e_addr_in (pck_injct_in.endp_addr),`
98			`.src_e_addr_in (current_e_addr),`
99			`.weight_in (pck_injct_in.init_weight),`
100			`.destport_in (destport),`
101			`.data_in (hdr_data_in),`
102			`.be_in({BEw{1'b1}} )// Be is not used in simulation as we dont sent real data`
103			`);`
104	48	alirezamon
105
106			`localparam`
107			`REMAIN_DATw = PCK_INJ_Dw - HDR_DATA_w,`
108			`REMAIN_DAT_FLIT_I = (REMAIN_DATw / Fpay),`
109			`REMAIN_DAT_FLIT_F = (REMAIN_DATw % Fpay == 0)? 0 : 1,`
110			`REMAIN_DAT_FLIT = REMAIN_DAT_FLIT_I + REMAIN_DAT_FLIT_F,`
111			`CNTw = log2(REMAIN_DAT_FLIT),`
112			`MIN_PCK_SIZ = REMAIN_DAT_FLIT +1;`
113
114
115	54	alirezamon	`logic [PCK_SIZw-1 : 0] counter, counter_next;`
116			`logic [CNTw-1 : 0] counter2,counter2_next;`
117	48	alirezamon	`reg tail,head;`
118
119			`wire [Fpay -1 : 0] remain_dat [REMAIN_DAT_FLIT -1 : 0];`
120			`wire [Fpay-1 : 0] dataIn = remain_dat[counter2];`
121	54	alirezamon	`enum bit [2:0] {HEADER, BODY,TAIL} flit_type,flit_type_next;`
122	48	alirezamon
123
124
125			`wire [V-1 : 0] wr_vc_send = (flit_wr)? pck_injct_in.vc : {V{1'b0}};`
126			`wire [V-1 : 0] vc_fifo_full;`
127
128
129			`wire noc_ready;`
130
131			`localparam`
132			`LAST_TMP =PCK_INJ_Dw - (Fpay*REMAIN_DAT_FLIT_I)-HDR_DATA_w,`
133			`LASTw=(LAST_TMP==0)? Fpay : LAST_TMP;`
134			`genvar i;`
135			`generate`
136	54	alirezamon	`for(i=0; i`
137	48	alirezamon	`assign remain_dat [i] = pck_injct_in.data [Fpay(i+1)+HDR_DATA_w-1 : (Fpayi)+HDR_DATA_w];`
138			`end`
139	54	alirezamon	`if(REMAIN_DAT_FLIT_F ) begin :flt`
140	48	alirezamon
141			`assign remain_dat [REMAIN_DAT_FLIT_I][LASTw-1 : 0] = pck_injct_in.data [PCK_INJ_Dw-1 : (Fpay*REMAIN_DAT_FLIT_I)+HDR_DATA_w];`
142			`end`
143			`endgenerate`
144
145
146
147
148
149	54	alirezamon	`one_hot_mux #(`
150	48	alirezamon	`.IN_WIDTH (V ),`
151			`.SEL_WIDTH (V ),`
152			`.OUT_WIDTH (1 )`
153	54	alirezamon	`) one_hot_mux1 (`
154	48	alirezamon	`.mux_in (~ vc_fifo_full ),`
155			`.mux_out (noc_ready ),`
156			`.sel (pck_injct_in.vc ));`
157
158
159
160
161	54	alirezamon	`always @ (*) begin`
162			`counter_next = counter;`
163			`counter2_next =counter2;`
164			`flit_type_next =flit_type;`
165			`tail=1'b0;`
166			`head=1'b0;`
167			`flit_wr=0;`
168			`if(noc_ready)begin`
169			`case(flit_type)`
170			`HEADER:begin`
171			`if(pck_injct_in.pck_wr)begin`
172	48	alirezamon	`flit_wr=1;`
173	54	alirezamon	`counter_next = pck_injct_in.size-1;`
174			`counter2_next=0;`
175			`head=1'b1;`
176			`if(pck_injct_in.size == 1)begin`
177			`tail=1'b1;`
178			`end else if (pck_injct_in.size == 2) begin`
179	48	alirezamon	`flit_type_next = TAIL;`
180	54	alirezamon	`end else begin`
181			`flit_type_next = BODY;`
182			`end`
183	48	alirezamon	`end`
184	54	alirezamon	`end`
185			`BODY: begin`
186			`flit_wr=1;`
187			`counter_next = counter -1'b1;`
188			`counter2_next =counter2 +1'b1;`
189			`if(counter == 2) begin`
190			`flit_type_next = TAIL;`
191	48	alirezamon	`end`
192	54	alirezamon	`end`
193			`TAIL: begin`
194			`flit_type_next = HEADER;`
195			`flit_wr=1;`
196			`tail=1'b1;`
197			`end`
198			`default: begin`
199
200			`end`
201			`endcase`
202	48	alirezamon
203			`end`
204	54	alirezamon	`end`
205	48	alirezamon
206	54	alirezamon	`logic [V-1 : 0] credit_o, credit_o_next;`
207	48	alirezamon
208	54	alirezamon	`//pronoc_register #(.W(3),.RESET_TO(HEADER) ) reg1 (.in(flit_type_next ), .out(flit_type), .reset(reset), .clk(clk));`
209			`pronoc_register #(.W(PCK_SIZw)) reg2 (.in(counter_next ), .out(counter), .reset(reset), .clk(clk));`
210			`pronoc_register #(.W(CNTw)) reg3 (.in(counter2_next ), .out(counter2), .reset(reset), .clk(clk));`
211			`pronoc_register #(.W(V)) reg4 (.in(credit_o_next ), .out(credit_o), .reset(reset), .clk(clk));`
212	48	alirezamon
213	54	alirezamon
214			`always @ (*) begin`
215			`credit_o_next = credit_o;`
216			`if (chan_in.flit_chanel.flit_wr) credit_o_next = chan_in.flit_chanel.flit.vc;`
217			`else credit_o_next = {V{1'b0}};`
218			`end`
219
220			always @(`pronoc_clk_reset_edge)begin
221			if(`pronoc_reset) flit_type<=HEADER;
222			`else flit_type <= flit_type_next;`
223			`end`
224	48	alirezamon
225
226
227			`injector_ovc_status #(`
228	54	alirezamon	`.V(V),`
229			`.B(LB),`
230			`.CRDTw(CRDTw)`
231			`)`
232			`the_ovc_status`
233			`(`
234			`.credit_init_val_in ( chan_in.ctrl_chanel.credit_init_val),`
235			`.wr_in(wr_vc_send),`
236			`.credit_in(chan_in.flit_chanel.credit),`
237			`.full_vc(vc_fifo_full),`
238			`.nearly_full_vc( ),`
239			`.empty_vc( ),`
240			`.clk(clk),`
241			`.reset(reset)`
242	56	alirezamon	`);`
243	48	alirezamon
244			`wire [HDR_DATA_w-1 : 0] hdr_data_o;`
245			`hdr_flit_t hdr_flit_i;`
246
247	56	alirezamon	`header_flit_info #(`
248			`.NOC_ID (NOC_ID),`
249			`.DATA_w (HDR_DATA_w)`
250			`) extractor (`
251			`.flit(chan_in.flit_chanel.flit),`
252			`.hdr_flit(hdr_flit_i),`
253			`.data_o(hdr_data_o)`
254			`);`
255	48	alirezamon
256			`wire [PCK_INJ_Dw-1 : 0] pck_data_o [V-1 : 0];`
257			`reg [Fpay-1 : 0] pck_data_o_gen [V-1 : 0][REMAIN_DAT_FLIT : 0];`
258
259			`genvar k;`
260
261			`reg [PCK_SIZw-1 : 0] rsv_counter [V-1 : 0];`
262			`reg [EAw-1 : 0] sender_endp_addr_reg [V-1 : 0];`
263			`logic [15:0] h2t_counter [V-1 : 0];`
264	56	alirezamon	`logic [15:0] h2t_counter_next [V-1 : 0];`
265	48	alirezamon
266			`//synthesis translate_off`
267			`wire [NEw-1 : 0] current_id;`
268			`wire [NEw-1 : 0] sendor_id;`
269			`endp_addr_decoder #( .TOPOLOGY(TOPOLOGY), .T1(T1), .T2(T2), .T3(T3), .EAw(EAw), .NE(NE)) encode1 ( .id(current_id), .code(current_e_addr));`
270	54	alirezamon	`endp_addr_decoder #( .TOPOLOGY(TOPOLOGY), .T1(T1), .T2(T2), .T3(T3), .EAw(EAw), .NE(NE)) encode2 ( .id(sendor_id), .code(pck_injct_out.endp_addr[EAw-1 : 0]));`
271	48	alirezamon	`//synthesis translate_on`
272
273	54	alirezamon	`wire [NE-1 :0] dest_mcast_all_endp;`
274	48	alirezamon
275	54	alirezamon
276
277
278	48	alirezamon	`generate`
279	54	alirezamon	`if(CAST_TYPE != "UNICAST") begin`
280	56	alirezamon	`mcast_dest_list_decode #(`
281			`.NOC_ID(NOC_ID)`
282			`) decode (`
283			`.dest_e_addr(hdr_flit_i.dest_e_addr),`
284			`.dest_o(dest_mcast_all_endp),`
285			`.row_has_any_dest(),`
286			`.is_unicast()`
287			`);`
288	54	alirezamon	`end`
289
290	48	alirezamon	`for(i=0; i`
291			`always@(*) begin`
292			`h2t_counter_next[i]=h2t_counter[i]+1'b1;`
293			`if(chan_in.flit_chanel.flit.vc[i] & chan_in.flit_chanel.flit_wr & chan_in.flit_chanel.flit.hdr_flag)begin`
294	54	alirezamon	`h2t_counter_next[i]= 16'd0; // reset once header flit is received`
295	48	alirezamon	`end//hdr flit wr`
296			`end//always`
297
298
299
300
301	54	alirezamon	always @ (`pronoc_clk_reset_edge )begin
302			if(`pronoc_reset) begin
303	48	alirezamon	`rsv_counter[i]<= {PCK_SIZw{1'b0}};`
304			`h2t_counter[i]<= 16'd0;`
305			`sender_endp_addr_reg [i]<= {EAw{1'b0}};`
306			`end else begin`
307			`h2t_counter[i]<=h2t_counter_next[i];`
308			`if(chan_in.flit_chanel.flit.vc[i] & chan_in.flit_chanel.flit_wr ) begin`
309			`if(chan_in.flit_chanel.flit.hdr_flag)begin`
310			`rsv_counter[i]<= {{(PCK_SIZw-1){1'b0}}, 1'b1};`
311			`sender_endp_addr_reg [i]<= hdr_flit_i.src_e_addr;`
312			`//synthesis translate_off`
313	54	alirezamon	`if(CAST_TYPE == "UNICAST") begin`
314			`if(hdr_flit_i.dest_e_addr[EAw-1:0] != current_e_addr) begin`
315	56	alirezamon	`$display("%t: ERROR: packet destination address %d does not match receiver endp address %d. %m",$time,hdr_flit_i.dest_e_addr , current_e_addr );`
316	54	alirezamon	`$finish;`
317			`end//if hdr_flit_i`
318			`end else begin`
319			`if(dest_mcast_all_endp[current_id] !=1'b1 ) begin`
320	56	alirezamon	`$display("%t: ERROR: packet destination address %b does not match receiver endp address %d. %m",$time,hdr_flit_i.dest_e_addr , current_e_addr ,current_id );`
321	54	alirezamon	`$finish;`
322			`end`
323	48	alirezamon	`end//if hdr_flit_i`
324			`//synthesis translate_on`
325			`end //if hdr_flag`
326			`else rsv_counter[i]<= rsv_counter[i]+1'b1;`
327			`end//flit wr`
328			`end//reset`
329			`end//always`
330
331
332
333
334			`for (k=0;k< REMAIN_DAT_FLIT+1;k++)begin : K_`
335
336	54	alirezamon	always @ (`pronoc_clk_reset_edge )begin
337			if(`pronoc_reset) begin
338	48	alirezamon	`pck_data_o_gen [i][k] <= {Fpay{1'b0}};`
339
340			`end else begin`
341			`if(chan_in.flit_chanel.flit.vc[i] & chan_in.flit_chanel.flit_wr ) begin`
342			`if (chan_in.flit_chanel.flit.hdr_flag )begin`
343			`if ( k ==0 ) pck_data_o_gen [i][k][HDR_DATA_w-1 : 0] <= hdr_data_o;`
344			`end`
345			`else begin`
346	54	alirezamon	`if (rsv_counter[i] == k ) pck_data_o_gen [i][k] <= chan_in.flit_chanel.flit.payload[Fpay-1 : 0];`
347	48	alirezamon
348			`end // else`
349			`end //if`
350			`end //else`
351			`end// always`
352
353	54	alirezamon	`if (k == 0 ) assign pck_data_o [i][HDR_DATA_w-1 : 0] = pck_data_o_gen [i][0][HDR_DATA_w-1 : 0];`
354			`else if (k == REMAIN_DAT_FLIT) assign pck_data_o [i][PCK_INJ_Dw-1 : (k-1)*Fpay+ HDR_DATA_w] = pck_data_o_gen [i][k][LASTw-1: 0];`
355			`else assign pck_data_o [i][(k)Fpay+HDR_DATA_w -1 : (k-1)Fpay+ HDR_DATA_w] = pck_data_o_gen [i][k];`
356	48	alirezamon
357			`end //for k`
358
359
360			`//synthesis translate_off`
361			`always @(posedge clk) begin`
362			`if((pck_injct_out.ready[i] == 1'b0 ) & pck_injct_in.vc[i] & pck_injct_in.pck_wr )begin`
363			`$display("%t: ERROR: a packet injection request is recived in core(%d), vc (%d) while packet injectore was not ready. %m",$time,current_id,i);`
364			`$finish;`
365			`end`
366
367			`end`
368			`//synthesis translate_on`
369
370
371
372
373			`end//for i`
374			`endgenerate`
375
376			`wire [V-1 : 0] vc_reg;`
377			`wire tail_flag_reg, hdr_flag_reg;`
378
379
380	54	alirezamon	`pronoc_register #(.W(V)) register1 (.in(chan_in.flit_chanel.flit.vc), .reset (reset ), .clk (clk),.out(vc_reg));`
381			`pronoc_register #(.W(1)) register2 (.in(chan_in.flit_chanel.flit.hdr_flag), .reset (reset ), .clk (clk),.out(hdr_flag_reg));`
382			`pronoc_register #(.W(1)) register3 (.in(chan_in.flit_chanel.flit.tail_flag & chan_in.flit_chanel.flit_wr ),.reset (reset ), .clk (clk),.out(tail_flag_reg));`
383	48	alirezamon
384			`wire [Vw-1 : 0] vc_bin;`
385
386			`one_hot_to_bin #(`
387	54	alirezamon	`.ONE_HOT_WIDTH (V),`
388			`.BIN_WIDTH (Vw )`
389			`) one_hot_to_bin (`
390			`.one_hot_code (vc_reg ),`
391			`.bin_code (vc_bin )`
392			`);`
393	48	alirezamon
394
395			`assign pck_injct_out.data = pck_data_o[vc_bin];`
396			`assign pck_injct_out.size = rsv_counter[vc_bin];`
397			`assign pck_injct_out.h2t_delay = h2t_counter[vc_bin];`
398			`assign pck_injct_out.ready = (flit_type == HEADER)? ~vc_fifo_full : {V{1'b0}};`
399	54	alirezamon	`assign pck_injct_out.endp_addr[EAw-1 : 0] = sender_endp_addr_reg[vc_bin];`
400	48	alirezamon	`assign pck_injct_out.vc = vc_reg;`
401			`assign pck_injct_out.pck_wr = tail_flag_reg;`
402
403			`assign chan_out.flit_chanel.flit.hdr_flag =head;`
404			`assign chan_out.flit_chanel.flit.tail_flag=tail;`
405			`assign chan_out.flit_chanel.flit.vc=pck_injct_in.vc;`
406			`assign chan_out.flit_chanel.flit_wr=flit_wr;`
407	54	alirezamon
408			`generate`
409			`/* verilator lint_off WIDTH */`
410			`if(PCK_TYPE == "SINGLE_FLIT" ) begin : single_f`
411			`/* verilator lint_on WIDTH */`
412			`assign chan_out.flit_chanel.flit.payload = hdr_flit_out[FPAYw-1 : 0];`
413			`end else begin`
414			`assign chan_out.flit_chanel.flit.payload = (flit_type== HEADER)? hdr_flit_out[Fpay-1 : 0] : dataIn;`
415			`end`
416			`endgenerate`
417
418	48	alirezamon	`assign chan_out.smart_chanel = {SMART_CHANEL_w{1'b0}};`
419			`assign chan_out.flit_chanel.congestion = {CONGw{1'b0}};`
420			`assign chan_out.flit_chanel.credit= credit_o;`
421			`assign chan_out.ctrl_chanel.credit_init_val= LB;`
422	54	alirezamon	`assign chan_out.ctrl_chanel.credit_release_en={V{1'b0}};`
423			`assign chan_out.ctrl_chanel.endp_port =1'b1;`
424	48	alirezamon
425
426
427			`distance_gen #(`
428			`.TOPOLOGY(TOPOLOGY),`
429			`.T1(T1),`
430			`.T2(T2),`
431			`.T3(T3),`
432			`.EAw(EAw),`
433			`.DISTw(DISTw)`
434			`)`
435			`the_distance_gen`
436			`(`
437			`.src_e_addr(sender_endp_addr_reg[vc_bin]),`
438			`.dest_e_addr(current_e_addr),`
439			`.distance(pck_injct_out.distance)`
440			`);`
441
442
443
444
445
446
447			`//synthesis translate_off`
448			//`define MONITOR_RSV_DAT
449
450
451
452			`always @(posedge clk) begin`
453			`if((pck_injct_in.vc == {V{1'b0}} ) & pck_injct_in.pck_wr )begin`
454			`$display("%t: ERROR: a packet injection request is recived while vc is not set. %m",$time);`
455			`$finish;`
456			`end`
457			`if(pck_injct_in.pck_wr && (pck_injct_in.size`
458			`$display("%t: ERROR: requested %d flit packet size is smaller than minimum %d flits to send %d bits of data. %m",$time,pck_injct_in.size,MIN_PCK_SIZ, PCK_INJ_Dw );`
459			`$finish;`
460			`end`
461
462			`ifdef MONITOR_RSV_DAT
463
464
465	54	alirezamon	`if(pck_injct_in.pck_wr) begin`
466			`$display ("pck_inj(%d) send a packet: size=%d, data=%h, v=%h",current_id,`
467			`pck_injct_in.size, pck_injct_in.data,pck_injct_in.vc);`
468			`end`
469	48	alirezamon
470	54	alirezamon	`if(pck_injct_out.pck_wr) begin`
471			`$display ("pck_inj(%d) got a packet: source=%d, size=%d, data=%h",current_id,`
472			`sendor_id,pck_injct_out.size,pck_injct_out.data);`
473			`end`
474	48	alirezamon
475
476			`endif
477
478			`end`
479
480
481			`//synthesis translate_on`
482
483
484
485
486
487			`endmodule`
488
489
490
491
492			`/******************`
493			`* ovc_status`
494			`*******************/`
495
496			`module injector_ovc_status #(`
497			`parameter V = 4,`
498			`parameter B = 16,`
499			`parameter CRDTw =4`
500			`)`

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_noc/] [packet_injector.sv] - Blame information for rev 56