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/] [src_c/] [jtag/] [test_rtl/] [jtag_ram_test/] [src_verilog/] [lib/] [arbiter.v] - Blame information for rev 38

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


 `timescale     1ns/1ps
/**********************************************************************
**      File: arbiter.v
**
**      Copyright (C) 2014-2017  Alireza Monemi
**
**      This file is part of ProNoC
**
**      ProNoC ( stands for Prototype Network-on-chip)  is free software:
**      you can redistribute it and/or modify it under the terms of the GNU
**      Lesser General Public License as published by the Free Software Foundation,
**      either version 2 of the License, or (at your option) any later version.
**
**      ProNoC is distributed in the hope that it will be useful, but WITHOUT
**      ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
**      or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
**      Public License for more details.
**
**      You should have received a copy of the GNU Lesser General Public
**      License along with ProNoC. If not, see <http:**www.gnu.org/licenses/>.
**
**
**
**      Description:
**      This file contains several Fixed prority and round robin
**      arbiters
**
******************************************************************************/
 
 
/*****************************************
*
* general round robin arbiter
*
*
******************************************/
 
module arbiter #(
    parameter    ARBITER_WIDTH    =8
 
)
(
   clk,
   reset,
   request,
   grant,
   any_grant
);
 
 
    input    [ARBITER_WIDTH-1             :    0]    request;
    output    [ARBITER_WIDTH-1            :    0]    grant;
    output                                        any_grant;
    input                                        clk;
    input                                        reset;
 
 
 
    generate
    if(ARBITER_WIDTH==1)  begin: w1
        assign grant= request;
        assign any_grant =request;
    end else if(ARBITER_WIDTH<=4) begin: w4
        //my own arbiter 
        my_one_hot_arbiter #(
            .ARBITER_WIDTH    (ARBITER_WIDTH)
        )
        one_hot_arb
        (
            .clk            (clk),
            .reset         (reset),
            .request        (request),
            .grant        (grant),
            .any_grant    (any_grant)
        );
 
    end else begin : wb4
 
        thermo_arbiter #(
            .ARBITER_WIDTH    (ARBITER_WIDTH)
        )
        one_hot_arb
        (
            .clk            (clk),
            .reset         (reset),
            .request        (request),
            .grant        (grant),
            .any_grant    (any_grant)
        );
    end
    endgenerate
endmodule
 
/*****************************************
*
*        arbiter_priority_en
* RRA with external priority enable signal
*
******************************************/
 
module arbiter_priority_en #(
        parameter    ARBITER_WIDTH    =8
 
)
(
   clk,
   reset,
   request,
   grant,
   any_grant,
   priority_en
);
 
 
 
 
    input        [ARBITER_WIDTH-1             :    0]    request;
    output    [ARBITER_WIDTH-1            :    0]    grant;
    output                                            any_grant;
    input                                                clk;
    input                                                reset;
    input                                              priority_en;
 
 
    generate
    if(ARBITER_WIDTH==1)  begin: w1
        assign grant= request;
        assign any_grant =request;
    end else if(ARBITER_WIDTH<=4) begin: w4
        //my own arbiter 
        my_one_hot_arbiter_priority_en #(
            .ARBITER_WIDTH    (ARBITER_WIDTH)
        )
        one_hot_arb
        (
            .clk            (clk),
            .reset         (reset),
            .request        (request),
            .grant        (grant),
            .any_grant    (any_grant),
            .priority_en (priority_en)
 
        );
 
    end else begin :wb4
 
        thermo_arbiter_priority_en #(
            .ARBITER_WIDTH    (ARBITER_WIDTH)
        )
        one_hot_arb
        (
            .clk            (clk),
            .reset         (reset),
            .request        (request),
            .grant        (grant),
            .any_grant    (any_grant),
            .priority_en (priority_en)
        );
    end
endgenerate
endmodule
 
 
 
/******************************************************
*       my_one_hot_arbiter
* RRA with binary-coded priority register. Binary-coded
* Priority results in less area cost and CPD for arbire
* width of 4 and smaller only.
*
******************************************************/
 
 
 
module my_one_hot_arbiter #(
    parameter ARBITER_WIDTH    =4
 
 
)
(
    input        [ARBITER_WIDTH-1             :    0]    request,
    output    [ARBITER_WIDTH-1            :    0]    grant,
    output                                            any_grant,
    input                                                clk,
    input                                                reset
);
 
    function integer log2;
      input integer number; begin
         log2=(number <=1) ? 1: 0;
         while(2**log2<number) begin
            log2=log2+1;
         end
      end
    endfunction // log2 
 
    localparam ARBITER_BIN_WIDTH= log2(ARBITER_WIDTH);
    reg     [ARBITER_BIN_WIDTH-1        :    0]     low_pr;
    wire     [ARBITER_BIN_WIDTH-1        :    0]     grant_bcd;
 
    one_hot_to_bin #(
        .ONE_HOT_WIDTH    (ARBITER_WIDTH)
    )conv
    (
    .one_hot_code(grant),
    .bin_code(grant_bcd)
 
    );
 
 
 
    always@(posedge clk or posedge reset) begin
        if(reset) begin
            low_pr    <=    {ARBITER_BIN_WIDTH{1'b0}};
        end else begin
            if(any_grant) low_pr <= grant_bcd;
        end
    end
 
 
    assign any_grant = | request;
 
    generate
        if(ARBITER_WIDTH    ==2) begin: w2        arbiter_2_one_hot arb( .in(request) , .out(grant), .low_pr(low_pr)); end
        if(ARBITER_WIDTH    ==3) begin: w3        arbiter_3_one_hot arb( .in(request) , .out(grant), .low_pr(low_pr)); end
        if(ARBITER_WIDTH    ==4) begin: w4        arbiter_4_one_hot arb( .in(request) , .out(grant), .low_pr(low_pr)); end
    endgenerate
 
endmodule
 
 
module arbiter_2_one_hot(
     input      [1             :    0]    in,
     output    reg[1                :    0]    out,
     input                                low_pr
);
always @(*) begin
     out=2'b00;
      case(low_pr)
         1'd0:
             if(in[1])                 out=2'b10;
             else if(in[0])         out=2'b01;
         1'd1:
             if(in[0])                 out=2'b01;
             else if(in[1])         out=2'b10;
          default: out=2'b00;
     endcase
  end
 endmodule
 
 
 
 
module arbiter_3_one_hot(
     input      [2             :    0]    in,
     output    reg[2                :    0]    out,
     input        [1                :    0]    low_pr
);
always @(*) begin
  out=3'b000;
      case(low_pr)
         2'd0:
             if(in[1])                 out=3'b010;
             else if(in[2])         out=3'b100;
             else if(in[0])         out=3'b001;
         2'd1:
             if(in[2])                 out=3'b100;
             else if(in[0])         out=3'b001;
             else if(in[1])         out=3'b010;
         2'd2:
             if(in[0])                 out=3'b001;
             else if(in[1])         out=3'b010;
             else if(in[2])         out=3'b100;
         default: out=3'b000;
     endcase
  end
 endmodule
 
 
 module arbiter_4_one_hot(
     input      [3             :    0]    in,
     output    reg[3                :    0]    out,
     input        [1                :    0]    low_pr
);
always @(*) begin
  out=4'b0000;
      case(low_pr)
         2'd0:
             if(in[1])                 out=4'b0010;
             else if(in[2])         out=4'b0100;
             else if(in[3])         out=4'b1000;
             else if(in[0])         out=4'b0001;
         2'd1:
             if(in[2])                 out=4'b0100;
             else if(in[3])         out=4'b1000;
             else if(in[0])         out=4'b0001;
             else if(in[1])         out=4'b0010;
         2'd2:
             if(in[3])                 out=4'b1000;
             else if(in[0])         out=4'b0001;
             else if(in[1])         out=4'b0010;
             else if(in[2])         out=4'b0100;
         2'd3:
             if(in[0])                 out=4'b0001;
             else if(in[1])         out=4'b0010;
             else if(in[2])         out=4'b0100;
             else if(in[3])         out=4'b1000;
         default: out=4'b0000;
     endcase
  end
 endmodule
 
 
/******************************************************
*       my_one_hot_arbiter_priority_en
*
******************************************************/
 
 
 
module my_one_hot_arbiter_priority_en #(
    parameter ARBITER_WIDTH    =4
 
 
)
(
    input        [ARBITER_WIDTH-1             :    0]    request,
    output    [ARBITER_WIDTH-1            :    0]    grant,
    output                                            any_grant,
    input                                                clk,
    input                                                reset,
    input                                                priority_en
);
 
    function integer log2;
      input integer number; begin
         log2=(number <=1) ? 1: 0;
         while(2**log2<number) begin
            log2=log2+1;
         end
      end
    endfunction // log2 
 
    localparam ARBITER_BIN_WIDTH= log2(ARBITER_WIDTH);
    reg     [ARBITER_BIN_WIDTH-1        :    0]     low_pr;
    wire     [ARBITER_BIN_WIDTH-1        :    0]     grant_bcd;
 
    one_hot_to_bin #(
        .ONE_HOT_WIDTH    (ARBITER_WIDTH)
    )conv
    (
        .one_hot_code(grant),
        .bin_code(grant_bcd)
    );
 
    always@(posedge clk or posedge reset) begin
        if(reset) begin
            low_pr    <=    {ARBITER_BIN_WIDTH{1'b0}};
        end else begin
            if(priority_en) low_pr <= grant_bcd;
        end
    end
 
 
    assign any_grant = | request;
 
    generate
        if(ARBITER_WIDTH    ==2) begin :w2        arbiter_2_one_hot arb( .in(request) , .out(grant), .low_pr(low_pr)); end
        if(ARBITER_WIDTH    ==3) begin :w3        arbiter_3_one_hot arb( .in(request) , .out(grant), .low_pr(low_pr)); end
        if(ARBITER_WIDTH    ==4) begin :w4        arbiter_4_one_hot arb( .in(request) , .out(grant), .low_pr(low_pr)); end
    endgenerate
 
endmodule
 
 
 
/*******************
*
*    thermo_arbiter RRA
*
********************/
 
module thermo_gen #(
    parameter WIDTH=16
 
 
)(
    input  [WIDTH-1    :    0]in,
    output [WIDTH-1    :    0]out
);
    genvar i;
    generate
    for(i=0;i<WIDTH;i=i+1)begin :lp
        assign out[i]= | in[i    :0];
    end
    endgenerate
 
endmodule
 
 
 
 
module thermo_arbiter #(
 parameter    ARBITER_WIDTH    =4
 
)
(
   clk,
   reset,
   request,
   grant,
   any_grant
);
 
 
 
 
    input        [ARBITER_WIDTH-1             :    0]    request;
    output    [ARBITER_WIDTH-1            :    0]    grant;
    output                                            any_grant;
    input                                                reset,clk;
 
 
    wire        [ARBITER_WIDTH-1             :    0]    termo1,termo2,mux_out,masked_request,edge_mask;
    reg        [ARBITER_WIDTH-1             :    0]    pr;
 
 
    thermo_gen #(
        .WIDTH(ARBITER_WIDTH)
    ) tm1
    (
        .in(request),
        .out(termo1)
    );
 
 
 
 
    thermo_gen #(
        .WIDTH(ARBITER_WIDTH)
    ) tm2
    (
        .in(masked_request),
        .out(termo2)
    );
 
 
assign mux_out=(termo2[ARBITER_WIDTH-1])? termo2 : termo1;
assign masked_request= request & pr;
assign any_grant=termo1[ARBITER_WIDTH-1];
 
always @(posedge clk or posedge reset)begin
    if(reset) pr<= {ARBITER_WIDTH{1'b1}};
    else begin
        if(any_grant) pr<= edge_mask;
    end
 
end
 
assign edge_mask= {mux_out[ARBITER_WIDTH-2:0],1'b0};
assign grant= mux_out ^ edge_mask;
 
 
 
endmodule
 
 
 
 
 
module thermo_arbiter_priority_en #(
 parameter    ARBITER_WIDTH    =4
 
)
(
   clk,
   reset,
   request,
   grant,
   any_grant,
   priority_en
);
 
 
 
 
    input        [ARBITER_WIDTH-1             :    0]    request;
    output    [ARBITER_WIDTH-1            :    0]    grant;
    output                                            any_grant;
    input                                                reset,clk;
    input priority_en;
 
    wire        [ARBITER_WIDTH-1             :    0]    termo1,termo2,mux_out,masked_request,edge_mask;
    reg        [ARBITER_WIDTH-1             :    0]    pr;
 
 
    thermo_gen #(
        .WIDTH(ARBITER_WIDTH)
    ) tm1
    (
        .in(request),
        .out(termo1)
    );
 
 
 
 
    thermo_gen #(
        .WIDTH(ARBITER_WIDTH)
    ) tm2
    (
        .in(masked_request),
        .out(termo2)
    );
 
 
assign mux_out=(termo2[ARBITER_WIDTH-1])? termo2 : termo1;
assign masked_request= request & pr;
assign any_grant=termo1[ARBITER_WIDTH-1];
 
always @(posedge clk or posedge reset)begin
    if(reset) pr<= {ARBITER_WIDTH{1'b1}};
    else begin
        if(priority_en) pr<= edge_mask;
    end
 
end
 
assign edge_mask= {mux_out[ARBITER_WIDTH-2:0],1'b0};
assign grant= mux_out ^ edge_mask;
 
 
 
endmodule
 
 
 
 
 
 
 
 
module thermo_arbiter_ext_priority #(
 parameter    ARBITER_WIDTH    =4
 
)
(
 
   request,
   grant,
   any_grant,
   priority_in
 
);
 
 
 
 
    input        [ARBITER_WIDTH-1             :    0]    request;
    output    [ARBITER_WIDTH-1            :    0]    grant;
    output                                            any_grant;
    input   [ARBITER_WIDTH-1            :   0]  priority_in;
 
    wire        [ARBITER_WIDTH-1             :    0]    termo1,termo2,mux_out,masked_request,edge_mask;
    wire        [ARBITER_WIDTH-1             :    0]    pr;
 
 
    thermo_gen #(
        .WIDTH(ARBITER_WIDTH)
    ) tm1
    (
        .in(request),
        .out(termo1)
    );
 
 
 
 
    thermo_gen #(
        .WIDTH(ARBITER_WIDTH)
    ) tm2
    (
        .in(masked_request),
        .out(termo2)
    );
 
 
    thermo_gen #(
        .WIDTH(ARBITER_WIDTH)
    ) tm3
    (
        .in(priority_in),
        .out(pr)
    );
 
 
assign mux_out=(termo2[ARBITER_WIDTH-1])? termo2 : termo1;
assign masked_request= request & pr;
assign any_grant=termo1[ARBITER_WIDTH-1];
 
 
assign edge_mask= {mux_out[ARBITER_WIDTH-2:0],1'b0};
assign grant= mux_out ^ edge_mask;
 
 
 
endmodule
 
 
 
/********************************
*
*   Tree arbiter
*
*******************************/
 
module tree_arbiter #(
        parameter    GROUP_NUM        =4,
        parameter    ARBITER_WIDTH    =16
)
(
   clk,
   reset,
   request,
   grant,
   any_grant
);
 
 
    function integer log2;
      input integer number; begin
         log2=(number <=1) ? 1: 0;
         while(2**log2<number) begin
            log2=log2+1;
         end
      end
    endfunction // log2 
 
  localparam N = ARBITER_WIDTH;
  localparam S = log2(ARBITER_WIDTH); // ceil of log_2 of N - put manually
 
 
  // I/O interface
  input           clk;
  input           reset;
  input  [N-1:0]  request;
  output [N-1:0]  grant;
  output          any_grant;
 
 
    localparam GROUP_WIDTH    =    ARBITER_WIDTH/GROUP_NUM;
 
  wire [GROUP_WIDTH-1        :    0]    group_req    [GROUP_NUM-1        :    0];
  wire [GROUP_WIDTH-1        :    0]    group_grant [GROUP_NUM-1        :    0];
  wire [GROUP_WIDTH-1        :    0]    grant_masked[GROUP_NUM-1        :    0];
 
  wire [GROUP_NUM-1            :    0] any_group_member_req;
  wire [GROUP_NUM-1            :    0] any_group_member_grant;
 
 
    genvar i;
    generate
    for (i=0;i<GROUP_NUM;i=i+1) begin :group_lp
 
        //seprate inputs in group
        assign group_req[i]    =    request[(i+1)*GROUP_WIDTH-1        :    i*GROUP_WIDTH];
 
        //check if any member of qrup has request
        assign any_group_member_req[i]    =    | group_req[i];
 
        //arbiterate one request from each group
        arbiter #(
            .ARBITER_WIDTH    (GROUP_WIDTH)
        )group_member_arbiter
        (
            .clk            (clk),
            .reset        (reset),
            .request        (group_req[i]),
            .grant        (group_grant[i]),
            .any_grant    ()
        );
 
    // mask the non selected groups        
        assign grant_masked [i] = (any_group_member_grant[i])?    group_grant[i]: {GROUP_WIDTH{1'b0}};
 
    //assemble the grants
        assign grant [(i+1)*GROUP_WIDTH-1        :    i*GROUP_WIDTH] = grant_masked [i];
 
 
    end
    endgenerate
 
    //select one group which has atleast one active request
 
    //arbiterate one request from each group
        arbiter #(
            .ARBITER_WIDTH    (GROUP_NUM)
        )second_arbiter
        (
            .clk        (clk),
            .reset        (reset),
            .request    (any_group_member_req),
            .grant        (any_group_member_grant),
            .any_grant    (any_grant)
        );
 
 
 
 endmodule
 
 
 
 
 
 
/*******************************
 
    my_one_hot_arbiter_ext_priority
 
*******************************/
 
module my_one_hot_arbiter_ext_priority #(
    parameter ARBITER_WIDTH =4
 
 
)
(
    input   [ARBITER_WIDTH-1            :   0]  request,
    input   [ARBITER_WIDTH-1            :   0]  priority_in,
    output  [ARBITER_WIDTH-1            :   0]  grant,
    output                                      any_grant
);
 
    function integer log2;
      input integer number; begin
         log2=(number <=1) ? 1: 0;
         while(2**log2<number) begin
            log2=log2+1;
         end
      end
    endfunction // log2 
 
    localparam ARBITER_BIN_WIDTH= log2(ARBITER_WIDTH);
    wire    [ARBITER_BIN_WIDTH-1        :   0]  low_pr;
 
 
    wire [ARBITER_WIDTH-1            :   0] low_pr_one_hot = {priority_in[0],priority_in[ARBITER_BIN_WIDTH-1:1]};
 
    one_hot_to_bin #(
        .ONE_HOT_WIDTH    (ARBITER_WIDTH)
    )conv
    (
        .one_hot_code(low_pr_one_hot),
        .bin_code(low_pr)
    );
 
 
    assign any_grant = | request;
 
    generate
        if(ARBITER_WIDTH    ==2) begin: w2       arbiter_2_one_hot arb( .in(request) , .out(grant), .low_pr(low_pr)); end
        if(ARBITER_WIDTH    ==3) begin: w3       arbiter_3_one_hot arb( .in(request) , .out(grant), .low_pr(low_pr)); end
        if(ARBITER_WIDTH    ==4) begin: w4       arbiter_4_one_hot arb( .in(request) , .out(grant), .low_pr(low_pr)); end
    endgenerate
 
endmodule
 
 
/*********************************
*
*       arbiter_ext_priority
*
**********************************/
 
 
 module arbiter_ext_priority  #(
        parameter   ARBITER_WIDTH   =8
 
)
(
 
   request,
   grant,
   priority_in,
   any_grant
);
 
 
    input   [ARBITER_WIDTH-1            :   0]  request;
    input   [ARBITER_WIDTH-1            :   0]  priority_in;
    output  [ARBITER_WIDTH-1            :   0]  grant;
    output                                      any_grant;
 
   /*
    generate
 
    if(ARBITER_WIDTH<=4) begin :ws4
        //my own arbiter
        my_one_hot_arbiter_ext_priority #(
            .ARBITER_WIDTH  (ARBITER_WIDTH)
        )
        one_hot_arb
        (
 
            .request    (request),
            .priority_in(priority_in),
            .grant      (grant),
            .any_grant  (any_grant)
        );
 
    end else begin :wb4
    */
 
        thermo_arbiter_ext_priority #(
            .ARBITER_WIDTH  (ARBITER_WIDTH)
        )
        one_hot_arb
        (
 
            .request    (request),
            .priority_in(priority_in),
            .grant      (grant),
            .any_grant   (any_grant)
        );
   // end
   // endgenerate
 
 
 
 
endmodule
 
 
 
 
 
 
 
 
 
 /*
 module fixed_priority_arbiter #(
     parameter   ARBITER_WIDTH   =8,
     parameter   HIGH_PRORITY_BIT = "HSB"
 )
 (
 
   request,
   grant,
   any_grant
);
 
 
    input   [ARBITER_WIDTH-1            :   0]  request;
    output  [ARBITER_WIDTH-1            :   0]  grant;
    output                                      any_grant;
 
    wire    [ARBITER_WIDTH-1            :   0]  cout;
    reg     [ARBITER_WIDTH-1            :   0]  cin;
 
 
    assign  any_grant= | request;
 
    assign grant    = cin & request;
    assign cout     = cin & ~request;
 
     always @(*) begin
        if( HIGH_PRORITY_BIT == "HSB")  cin      = {1'b1, cout[ARBITER_WIDTH-1 :1]}; // hsb has highest priority
        else                            cin      = {cout[ARBITER_WIDTH-2 :0] ,1'b1}; // lsb has highest priority
    end//always
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/] [src_c/] [jtag/] [test_rtl/] [jtag_ram_test/] [src_verilog/] [lib/] [arbiter.v] - Blame information for rev 38

Line No.	Rev	Author	Line
1	38	alirezamon	`timescale 1ns/1ps
2			`/**********************************************************************`
3			`** File: arbiter.v`
4			`**`
5			`** Copyright (C) 2014-2017 Alireza Monemi`
6			`**`
7			`** This file is part of ProNoC`
8			`**`
9			`** ProNoC ( stands for Prototype Network-on-chip) is free software:`
10			`** you can redistribute it and/or modify it under the terms of the GNU`
11			`** Lesser General Public License as published by the Free Software Foundation,`
12			`** either version 2 of the License, or (at your option) any later version.`
13			`**`
14			`** ProNoC is distributed in the hope that it will be useful, but WITHOUT`
15			`** ANY WARRANTY; without even the implied warranty of MERCHANTABILITY`
16			`** or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General`
17			`** Public License for more details.`
18			`**`
19			`** You should have received a copy of the GNU Lesser General Public`
20			` License along with ProNoC. If not, see <http:www.gnu.org/licenses/>.`
21			`**`
22			`**`
23			`**`
24			`** Description:`
25			`** This file contains several Fixed prority and round robin`
26			`** arbiters`
27			`**`
28			`******************************************************************************/`
29
30
31			`/*****************************************`
32			`*`
33			`* general round robin arbiter`
34			`*`
35			`*`
36			`******************************************/`
37
38			`module arbiter #(`
39			`parameter ARBITER_WIDTH =8`
40
41			`)`
42			`(`
43			`clk,`
44			`reset,`
45			`request,`
46			`grant,`
47			`any_grant`
48			`);`
49
50
51			`input [ARBITER_WIDTH-1 : 0] request;`
52			`output [ARBITER_WIDTH-1 : 0] grant;`
53			`output any_grant;`
54			`input clk;`
55			`input reset;`
56
57
58
59			`generate`
60			`if(ARBITER_WIDTH==1) begin: w1`
61			`assign grant= request;`
62			`assign any_grant =request;`
63			`end else if(ARBITER_WIDTH<=4) begin: w4`
64			`//my own arbiter`
65			`my_one_hot_arbiter #(`
66			`.ARBITER_WIDTH (ARBITER_WIDTH)`
67			`)`
68			`one_hot_arb`
69			`(`
70			`.clk (clk),`
71			`.reset (reset),`
72			`.request (request),`
73			`.grant (grant),`
74			`.any_grant (any_grant)`
75			`);`
76
77			`end else begin : wb4`
78
79			`thermo_arbiter #(`
80			`.ARBITER_WIDTH (ARBITER_WIDTH)`
81			`)`
82			`one_hot_arb`
83			`(`
84			`.clk (clk),`
85			`.reset (reset),`
86			`.request (request),`
87			`.grant (grant),`
88			`.any_grant (any_grant)`
89			`);`
90			`end`
91			`endgenerate`
92			`endmodule`
93
94			`/*****************************************`
95			`*`
96			`* arbiter_priority_en`
97			`* RRA with external priority enable signal`
98			`*`
99			`******************************************/`
100
101			`module arbiter_priority_en #(`
102			`parameter ARBITER_WIDTH =8`
103
104			`)`
105			`(`
106			`clk,`
107			`reset,`
108			`request,`
109			`grant,`
110			`any_grant,`
111			`priority_en`
112			`);`
113
114
115
116
117			`input [ARBITER_WIDTH-1 : 0] request;`
118			`output [ARBITER_WIDTH-1 : 0] grant;`
119			`output any_grant;`
120			`input clk;`
121			`input reset;`
122			`input priority_en;`
123
124
125			`generate`
126			`if(ARBITER_WIDTH==1) begin: w1`
127			`assign grant= request;`
128			`assign any_grant =request;`
129			`end else if(ARBITER_WIDTH<=4) begin: w4`
130			`//my own arbiter`
131			`my_one_hot_arbiter_priority_en #(`
132			`.ARBITER_WIDTH (ARBITER_WIDTH)`
133			`)`
134			`one_hot_arb`
135			`(`
136			`.clk (clk),`
137			`.reset (reset),`
138			`.request (request),`
139			`.grant (grant),`
140			`.any_grant (any_grant),`
141			`.priority_en (priority_en)`
142
143			`);`
144
145			`end else begin :wb4`
146
147			`thermo_arbiter_priority_en #(`
148			`.ARBITER_WIDTH (ARBITER_WIDTH)`
149			`)`
150			`one_hot_arb`
151			`(`
152			`.clk (clk),`
153			`.reset (reset),`
154			`.request (request),`
155			`.grant (grant),`
156			`.any_grant (any_grant),`
157			`.priority_en (priority_en)`
158			`);`
159			`end`
160			`endgenerate`
161			`endmodule`
162
163
164
165			`/******************************************************`
166			`* my_one_hot_arbiter`
167			`* RRA with binary-coded priority register. Binary-coded`
168			`* Priority results in less area cost and CPD for arbire`
169			`* width of 4 and smaller only.`
170			`*`
171			`******************************************************/`
172
173
174
175			`module my_one_hot_arbiter #(`
176			`parameter ARBITER_WIDTH =4`
177
178
179			`)`
180			`(`
181			`input [ARBITER_WIDTH-1 : 0] request,`
182			`output [ARBITER_WIDTH-1 : 0] grant,`
183			`output any_grant,`
184			`input clk,`
185			`input reset`
186			`);`
187
188			`function integer log2;`
189			`input integer number; begin`
190			`log2=(number <=1) ? 1: 0;`
191			`while(2**log2<number) begin`
192			`log2=log2+1;`
193			`end`
194			`end`
195			`endfunction // log2`
196
197			`localparam ARBITER_BIN_WIDTH= log2(ARBITER_WIDTH);`
198			`reg [ARBITER_BIN_WIDTH-1 : 0] low_pr;`
199			`wire [ARBITER_BIN_WIDTH-1 : 0] grant_bcd;`
200
201			`one_hot_to_bin #(`
202			`.ONE_HOT_WIDTH (ARBITER_WIDTH)`
203			`)conv`
204			`(`
205			`.one_hot_code(grant),`
206			`.bin_code(grant_bcd)`
207
208			`);`
209
210
211
212			`always@(posedge clk or posedge reset) begin`
213			`if(reset) begin`
214			`low_pr <= {ARBITER_BIN_WIDTH{1'b0}};`
215			`end else begin`
216			`if(any_grant) low_pr <= grant_bcd;`
217			`end`
218			`end`
219
220
221			`assign any_grant = \| request;`
222
223			`generate`
224			`if(ARBITER_WIDTH ==2) begin: w2 arbiter_2_one_hot arb( .in(request) , .out(grant), .low_pr(low_pr)); end`
225			`if(ARBITER_WIDTH ==3) begin: w3 arbiter_3_one_hot arb( .in(request) , .out(grant), .low_pr(low_pr)); end`
226			`if(ARBITER_WIDTH ==4) begin: w4 arbiter_4_one_hot arb( .in(request) , .out(grant), .low_pr(low_pr)); end`
227			`endgenerate`
228
229			`endmodule`
230
231
232			`module arbiter_2_one_hot(`
233			`input [1 : 0] in,`
234			`output reg[1 : 0] out,`
235			`input low_pr`
236			`);`
237			`always @(*) begin`
238			`out=2'b00;`
239			`case(low_pr)`
240			`1'd0:`
241			`if(in[1]) out=2'b10;`
242			`else if(in[0]) out=2'b01;`
243			`1'd1:`
244			`if(in[0]) out=2'b01;`
245			`else if(in[1]) out=2'b10;`
246			`default: out=2'b00;`
247			`endcase`
248			`end`
249			`endmodule`
250
251
252
253
254			`module arbiter_3_one_hot(`
255			`input [2 : 0] in,`
256			`output reg[2 : 0] out,`
257			`input [1 : 0] low_pr`
258			`);`
259			`always @(*) begin`
260			`out=3'b000;`
261			`case(low_pr)`
262			`2'd0:`
263			`if(in[1]) out=3'b010;`
264			`else if(in[2]) out=3'b100;`
265			`else if(in[0]) out=3'b001;`
266			`2'd1:`
267			`if(in[2]) out=3'b100;`
268			`else if(in[0]) out=3'b001;`
269			`else if(in[1]) out=3'b010;`
270			`2'd2:`
271			`if(in[0]) out=3'b001;`
272			`else if(in[1]) out=3'b010;`
273			`else if(in[2]) out=3'b100;`
274			`default: out=3'b000;`
275			`endcase`
276			`end`
277			`endmodule`
278
279
280			`module arbiter_4_one_hot(`
281			`input [3 : 0] in,`
282			`output reg[3 : 0] out,`
283			`input [1 : 0] low_pr`
284			`);`
285			`always @(*) begin`
286			`out=4'b0000;`
287			`case(low_pr)`
288			`2'd0:`
289			`if(in[1]) out=4'b0010;`
290			`else if(in[2]) out=4'b0100;`
291			`else if(in[3]) out=4'b1000;`
292			`else if(in[0]) out=4'b0001;`
293			`2'd1:`
294			`if(in[2]) out=4'b0100;`
295			`else if(in[3]) out=4'b1000;`
296			`else if(in[0]) out=4'b0001;`
297			`else if(in[1]) out=4'b0010;`
298			`2'd2:`
299			`if(in[3]) out=4'b1000;`
300			`else if(in[0]) out=4'b0001;`
301			`else if(in[1]) out=4'b0010;`
302			`else if(in[2]) out=4'b0100;`
303			`2'd3:`
304			`if(in[0]) out=4'b0001;`
305			`else if(in[1]) out=4'b0010;`
306			`else if(in[2]) out=4'b0100;`
307			`else if(in[3]) out=4'b1000;`
308			`default: out=4'b0000;`
309			`endcase`
310			`end`
311			`endmodule`
312
313
314			`/******************************************************`
315			`* my_one_hot_arbiter_priority_en`
316			`*`
317			`******************************************************/`
318
319
320
321			`module my_one_hot_arbiter_priority_en #(`
322			`parameter ARBITER_WIDTH =4`
323
324
325			`)`
326			`(`
327			`input [ARBITER_WIDTH-1 : 0] request,`
328			`output [ARBITER_WIDTH-1 : 0] grant,`
329			`output any_grant,`
330			`input clk,`
331			`input reset,`
332			`input priority_en`
333			`);`
334
335			`function integer log2;`
336			`input integer number; begin`
337			`log2=(number <=1) ? 1: 0;`
338			`while(2**log2<number) begin`
339			`log2=log2+1;`
340			`end`
341			`end`
342			`endfunction // log2`
343
344			`localparam ARBITER_BIN_WIDTH= log2(ARBITER_WIDTH);`
345			`reg [ARBITER_BIN_WIDTH-1 : 0] low_pr;`
346			`wire [ARBITER_BIN_WIDTH-1 : 0] grant_bcd;`
347
348			`one_hot_to_bin #(`
349			`.ONE_HOT_WIDTH (ARBITER_WIDTH)`
350			`)conv`
351			`(`
352			`.one_hot_code(grant),`
353			`.bin_code(grant_bcd)`
354			`);`
355
356			`always@(posedge clk or posedge reset) begin`
357			`if(reset) begin`
358			`low_pr <= {ARBITER_BIN_WIDTH{1'b0}};`
359			`end else begin`
360			`if(priority_en) low_pr <= grant_bcd;`
361			`end`
362			`end`
363
364
365			`assign any_grant = \| request;`
366
367			`generate`
368			`if(ARBITER_WIDTH ==2) begin :w2 arbiter_2_one_hot arb( .in(request) , .out(grant), .low_pr(low_pr)); end`
369			`if(ARBITER_WIDTH ==3) begin :w3 arbiter_3_one_hot arb( .in(request) , .out(grant), .low_pr(low_pr)); end`
370			`if(ARBITER_WIDTH ==4) begin :w4 arbiter_4_one_hot arb( .in(request) , .out(grant), .low_pr(low_pr)); end`
371			`endgenerate`
372
373			`endmodule`
374
375
376
377			`/*******************`
378			`*`
379			`* thermo_arbiter RRA`
380			`*`
381			`********************/`
382
383			`module thermo_gen #(`
384			`parameter WIDTH=16`
385
386
387			`)(`
388			`input [WIDTH-1 : 0]in,`
389			`output [WIDTH-1 : 0]out`
390			`);`
391			`genvar i;`
392			`generate`
393			`for(i=0;i<WIDTH;i=i+1)begin :lp`
394			`assign out[i]= \| in[i :0];`
395			`end`
396			`endgenerate`
397
398			`endmodule`
399
400
401
402
403			`module thermo_arbiter #(`
404			`parameter ARBITER_WIDTH =4`
405
406			`)`
407			`(`
408			`clk,`
409			`reset,`
410			`request,`
411			`grant,`
412			`any_grant`
413			`);`
414
415
416
417
418			`input [ARBITER_WIDTH-1 : 0] request;`
419			`output [ARBITER_WIDTH-1 : 0] grant;`
420			`output any_grant;`
421			`input reset,clk;`
422
423
424			`wire [ARBITER_WIDTH-1 : 0] termo1,termo2,mux_out,masked_request,edge_mask;`
425			`reg [ARBITER_WIDTH-1 : 0] pr;`
426
427
428			`thermo_gen #(`
429			`.WIDTH(ARBITER_WIDTH)`
430			`) tm1`
431			`(`
432			`.in(request),`
433			`.out(termo1)`
434			`);`
435
436
437
438
439			`thermo_gen #(`
440			`.WIDTH(ARBITER_WIDTH)`
441			`) tm2`
442			`(`
443			`.in(masked_request),`
444			`.out(termo2)`
445			`);`
446
447
448			`assign mux_out=(termo2[ARBITER_WIDTH-1])? termo2 : termo1;`
449			`assign masked_request= request & pr;`
450			`assign any_grant=termo1[ARBITER_WIDTH-1];`
451
452			`always @(posedge clk or posedge reset)begin`
453			`if(reset) pr<= {ARBITER_WIDTH{1'b1}};`
454			`else begin`
455			`if(any_grant) pr<= edge_mask;`
456			`end`
457
458			`end`
459
460			`assign edge_mask= {mux_out[ARBITER_WIDTH-2:0],1'b0};`
461			`assign grant= mux_out ^ edge_mask;`
462
463
464
465			`endmodule`
466
467
468
469
470
471			`module thermo_arbiter_priority_en #(`
472			`parameter ARBITER_WIDTH =4`
473
474			`)`
475			`(`
476			`clk,`
477			`reset,`
478			`request,`
479			`grant,`
480			`any_grant,`
481			`priority_en`
482			`);`
483
484
485
486
487			`input [ARBITER_WIDTH-1 : 0] request;`
488			`output [ARBITER_WIDTH-1 : 0] grant;`
489			`output any_grant;`
490			`input reset,clk;`
491			`input priority_en;`
492
493			`wire [ARBITER_WIDTH-1 : 0] termo1,termo2,mux_out,masked_request,edge_mask;`
494			`reg [ARBITER_WIDTH-1 : 0] pr;`
495
496
497			`thermo_gen #(`
498			`.WIDTH(ARBITER_WIDTH)`
499			`) tm1`
500			`(`
501			`.in(request),`
502			`.out(termo1)`
503			`);`
504
505
506
507
508			`thermo_gen #(`
509			`.WIDTH(ARBITER_WIDTH)`
510			`) tm2`
511			`(`
512			`.in(masked_request),`
513			`.out(termo2)`
514			`);`
515
516
517			`assign mux_out=(termo2[ARBITER_WIDTH-1])? termo2 : termo1;`
518			`assign masked_request= request & pr;`
519			`assign any_grant=termo1[ARBITER_WIDTH-1];`
520
521			`always @(posedge clk or posedge reset)begin`
522			`if(reset) pr<= {ARBITER_WIDTH{1'b1}};`
523			`else begin`
524			`if(priority_en) pr<= edge_mask;`
525			`end`
526
527			`end`
528
529			`assign edge_mask= {mux_out[ARBITER_WIDTH-2:0],1'b0};`
530			`assign grant= mux_out ^ edge_mask;`
531
532
533
534			`endmodule`
535
536
537
538
539
540
541
542
543			`module thermo_arbiter_ext_priority #(`
544			`parameter ARBITER_WIDTH =4`
545
546			`)`
547			`(`
548
549			`request,`
550			`grant,`
551			`any_grant,`
552			`priority_in`
553
554			`);`
555
556
557
558
559			`input [ARBITER_WIDTH-1 : 0] request;`
560			`output [ARBITER_WIDTH-1 : 0] grant;`
561			`output any_grant;`
562			`input [ARBITER_WIDTH-1 : 0] priority_in;`
563
564			`wire [ARBITER_WIDTH-1 : 0] termo1,termo2,mux_out,masked_request,edge_mask;`
565			`wire [ARBITER_WIDTH-1 : 0] pr;`
566
567
568			`thermo_gen #(`
569			`.WIDTH(ARBITER_WIDTH)`
570			`) tm1`
571			`(`
572			`.in(request),`
573			`.out(termo1)`
574			`);`
575
576
577
578
579			`thermo_gen #(`
580			`.WIDTH(ARBITER_WIDTH)`
581			`) tm2`
582			`(`
583			`.in(masked_request),`
584			`.out(termo2)`
585			`);`
586
587
588			`thermo_gen #(`
589			`.WIDTH(ARBITER_WIDTH)`
590			`) tm3`
591			`(`
592			`.in(priority_in),`
593			`.out(pr)`
594			`);`
595
596
597			`assign mux_out=(termo2[ARBITER_WIDTH-1])? termo2 : termo1;`
598			`assign masked_request= request & pr;`
599			`assign any_grant=termo1[ARBITER_WIDTH-1];`
600
601
602			`assign edge_mask= {mux_out[ARBITER_WIDTH-2:0],1'b0};`
603			`assign grant= mux_out ^ edge_mask;`
604
605
606
607			`endmodule`
608
609
610
611			`/********************************`
612			`*`
613			`* Tree arbiter`
614			`*`
615			`*******************************/`
616
617			`module tree_arbiter #(`
618			`parameter GROUP_NUM =4,`
619			`parameter ARBITER_WIDTH =16`
620			`)`
621			`(`
622			`clk,`
623			`reset,`
624			`request,`
625			`grant,`
626			`any_grant`
627			`);`
628
629
630			`function integer log2;`
631			`input integer number; begin`
632			`log2=(number <=1) ? 1: 0;`
633			`while(2**log2<number) begin`
634			`log2=log2+1;`
635			`end`
636			`end`
637			`endfunction // log2`
638
639			`localparam N = ARBITER_WIDTH;`
640			`localparam S = log2(ARBITER_WIDTH); // ceil of log_2 of N - put manually`
641
642
643			`// I/O interface`
644			`input clk;`
645			`input reset;`
646			`input [N-1:0] request;`
647			`output [N-1:0] grant;`
648			`output any_grant;`
649
650
651			`localparam GROUP_WIDTH = ARBITER_WIDTH/GROUP_NUM;`
652
653			`wire [GROUP_WIDTH-1 : 0] group_req [GROUP_NUM-1 : 0];`
654			`wire [GROUP_WIDTH-1 : 0] group_grant [GROUP_NUM-1 : 0];`
655			`wire [GROUP_WIDTH-1 : 0] grant_masked[GROUP_NUM-1 : 0];`
656
657			`wire [GROUP_NUM-1 : 0] any_group_member_req;`
658			`wire [GROUP_NUM-1 : 0] any_group_member_grant;`
659
660
661			`genvar i;`
662			`generate`
663			`for (i=0;i<GROUP_NUM;i=i+1) begin :group_lp`
664
665			`//seprate inputs in group`
666			`assign group_req[i] = request[(i+1)GROUP_WIDTH-1 : iGROUP_WIDTH];`
667
668			`//check if any member of qrup has request`
669			`assign any_group_member_req[i] = \| group_req[i];`
670
671			`//arbiterate one request from each group`
672			`arbiter #(`
673			`.ARBITER_WIDTH (GROUP_WIDTH)`
674			`)group_member_arbiter`
675			`(`
676			`.clk (clk),`
677			`.reset (reset),`
678			`.request (group_req[i]),`
679			`.grant (group_grant[i]),`
680			`.any_grant ()`
681			`);`
682
683			`// mask the non selected groups`
684			`assign grant_masked [i] = (any_group_member_grant[i])? group_grant[i]: {GROUP_WIDTH{1'b0}};`
685
686			`//assemble the grants`
687			`assign grant [(i+1)GROUP_WIDTH-1 : iGROUP_WIDTH] = grant_masked [i];`
688
689
690			`end`
691			`endgenerate`
692
693			`//select one group which has atleast one active request`
694
695			`//arbiterate one request from each group`
696			`arbiter #(`
697			`.ARBITER_WIDTH (GROUP_NUM)`
698			`)second_arbiter`
699			`(`
700			`.clk (clk),`
701			`.reset (reset),`
702			`.request (any_group_member_req),`
703			`.grant (any_group_member_grant),`
704			`.any_grant (any_grant)`
705			`);`
706
707
708
709			`endmodule`
710
711
712
713
714
715
716			`/*******************************`
717
718			`my_one_hot_arbiter_ext_priority`
719
720			`*******************************/`
721
722			`module my_one_hot_arbiter_ext_priority #(`
723			`parameter ARBITER_WIDTH =4`
724
725
726			`)`
727			`(`
728			`input [ARBITER_WIDTH-1 : 0] request,`
729			`input [ARBITER_WIDTH-1 : 0] priority_in,`
730			`output [ARBITER_WIDTH-1 : 0] grant,`
731			`output any_grant`
732			`);`
733
734			`function integer log2;`
735			`input integer number; begin`
736			`log2=(number <=1) ? 1: 0;`
737			`while(2**log2<number) begin`
738			`log2=log2+1;`
739			`end`
740			`end`
741			`endfunction // log2`
742
743			`localparam ARBITER_BIN_WIDTH= log2(ARBITER_WIDTH);`
744			`wire [ARBITER_BIN_WIDTH-1 : 0] low_pr;`
745
746
747			`wire [ARBITER_WIDTH-1 : 0] low_pr_one_hot = {priority_in[0],priority_in[ARBITER_BIN_WIDTH-1:1]};`
748
749			`one_hot_to_bin #(`
750			`.ONE_HOT_WIDTH (ARBITER_WIDTH)`
751			`)conv`
752			`(`
753			`.one_hot_code(low_pr_one_hot),`
754			`.bin_code(low_pr)`
755			`);`
756
757
758			`assign any_grant = \| request;`
759
760			`generate`
761			`if(ARBITER_WIDTH ==2) begin: w2 arbiter_2_one_hot arb( .in(request) , .out(grant), .low_pr(low_pr)); end`
762			`if(ARBITER_WIDTH ==3) begin: w3 arbiter_3_one_hot arb( .in(request) , .out(grant), .low_pr(low_pr)); end`
763			`if(ARBITER_WIDTH ==4) begin: w4 arbiter_4_one_hot arb( .in(request) , .out(grant), .low_pr(low_pr)); end`
764			`endgenerate`
765
766			`endmodule`
767
768
769			`/*********************************`
770			`*`
771			`* arbiter_ext_priority`
772			`*`
773			`**********************************/`
774
775
776			`module arbiter_ext_priority #(`
777			`parameter ARBITER_WIDTH =8`
778
779			`)`
780			`(`
781
782			`request,`
783			`grant,`
784			`priority_in,`
785			`any_grant`
786			`);`
787
788
789			`input [ARBITER_WIDTH-1 : 0] request;`
790			`input [ARBITER_WIDTH-1 : 0] priority_in;`
791			`output [ARBITER_WIDTH-1 : 0] grant;`
792			`output any_grant;`
793
794			`/*`
795			`generate`
796
797			`if(ARBITER_WIDTH<=4) begin :ws4`
798			`//my own arbiter`
799			`my_one_hot_arbiter_ext_priority #(`
800			`.ARBITER_WIDTH (ARBITER_WIDTH)`
801			`)`
802			`one_hot_arb`
803			`(`
804
805			`.request (request),`
806			`.priority_in(priority_in),`
807			`.grant (grant),`
808			`.any_grant (any_grant)`
809			`);`
810
811			`end else begin :wb4`
812			`*/`
813
814			`thermo_arbiter_ext_priority #(`
815			`.ARBITER_WIDTH (ARBITER_WIDTH)`
816			`)`
817			`one_hot_arb`
818			`(`
819
820			`.request (request),`
821			`.priority_in(priority_in),`
822			`.grant (grant),`
823			`.any_grant (any_grant)`
824			`);`
825			`// end`
826			`// endgenerate`
827
828
829
830
831			`endmodule`
832
833
834
835
836
837
838
839
840
841			`/*`
842			`module fixed_priority_arbiter #(`
843			`parameter ARBITER_WIDTH =8,`
844			`parameter HIGH_PRORITY_BIT = "HSB"`
845			`)`
846			`(`
847
848			`request,`
849			`grant,`
850			`any_grant`
851			`);`
852
853
854			`input [ARBITER_WIDTH-1 : 0] request;`
855			`output [ARBITER_WIDTH-1 : 0] grant;`
856			`output any_grant;`
857
858			`wire [ARBITER_WIDTH-1 : 0] cout;`
859			`reg [ARBITER_WIDTH-1 : 0] cin;`
860
861
862			`assign any_grant= \| request;`
863
864			`assign grant = cin & request;`
865			`assign cout = cin & ~request;`
866
867			`always @(*) begin`
868			`if( HIGH_PRORITY_BIT == "HSB") cin = {1'b1, cout[ARBITER_WIDTH-1 :1]}; // hsb has highest priority`
869			`else cin = {cout[ARBITER_WIDTH-2 :0] ,1'b1}; // lsb has highest priority`
870			`end//always`
871			`endmodule`
872
873			`*/`
874
875
876
877