arbiter_rr.v

/**
 * Round-Robin Arbiter Module
 * 
 * This module implements an arbiter with configurable priority schemes,
 * optimized for round-robin (fair) arbitration. It provides fair access
 * to a shared resource by rotating priority after each grant.
 * 
 * Priority Schemes:
 * 1. Fixed Priority (PRIORITY_SCHEME = 0):
 *    - Higher port indices have higher priority
 *    - Simple but can starve lower-priority ports
 * 
 * 2. Round-Robin (PRIORITY_SCHEME = 1):
 *    - Priority rotates after each grant
 *    - Provides fairness and prevents starvation
 *    - Cycles through ports starting from last granted port
 * 
 * Design Notes:
 * - Default is round-robin (PRIORITY_SCHEME = 1)
 * - Priority pointer cycles downward (wraps around)
 * - Only one port can be granted per cycle (mutual exclusion)
 * 
 * @param NUM_PORTS Number of ports competing for access (default: 4)
 * @param PRIORITY_SCHEME 0 = Fixed, 1 = Round-robin (default: 1)
 * 
 * @input clk Clock signal
 * @input rst_n Active-low reset signal
 * @input request[NUM_PORTS-1:0] Request signals from each port
 * @output grant[NUM_PORTS-1:0] Grant signals (one-hot)
 * @output active High when any port is granted
 */
module arbiter_rr #(
    parameter NUM_PORTS = 4,
    parameter PRIORITY_SCHEME = 1  // 0: Fixed priority, 1: Round-robin
) (
    input wire clk,
    input wire rst_n,
    input wire [NUM_PORTS-1:0] request,
    output reg [NUM_PORTS-1:0] grant,
    output wire active          // Indicates if any request is being serviced
);

    // ============================================================================
    // Internal State Registers
    // ============================================================================
    // Priority pointer for round-robin: tracks which port has highest priority
    reg [$clog2(NUM_PORTS)-1:0] priority_ptr;
    
    // ============================================================================
    // Active Signal Generation
    // ============================================================================
    // Active signal indicates when any port is currently granted access
    assign active = |grant;
    
    // ============================================================================
    // Main Arbitration Logic
    // ============================================================================
    // Temporary variables for arbitration computation
    reg [1:0] found;      // Flag for fixed priority scheme
    reg [1:0] granted;    // Flag for round-robin scheme
    reg [1:0] ptr;        // Temporary pointer copy
    reg [1:0] check_idx;   // Current port index being checked
    integer i;             // Loop counter
    
    always @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            // ====================================================================
            // Reset State
            // ====================================================================
            grant <= {NUM_PORTS{1'b0}};
            // Initialize priority pointer to highest port (for round-robin)
            priority_ptr <= NUM_PORTS-1;
        end else begin
            // ====================================================================
            // Default: No Grants
            // ====================================================================
            grant <= {NUM_PORTS{1'b0}};
            
            // Only perform arbitration if at least one port is requesting
            if (|request) begin
                if (PRIORITY_SCHEME == 0) begin
                    // ============================================================
                    // Fixed Priority Scheme
                    // ============================================================
                    // Higher port indices have higher priority
                    // Check ports from highest to lowest index
                    /* verilator lint_off BLKSEQ */
                    found = 0;
                    // Check ports in priority order (3, 2, 1, 0)
                    if (request[3] && !found) begin grant[3] <= 1'b1; found = 1; end
                    if (request[2] && !found) begin grant[2] <= 1'b1; found = 1; end
                    if (request[1] && !found) begin grant[1] <= 1'b1; found = 1; end
                    if (request[0] && !found) begin grant[0] <= 1'b1; found = 1; end
                    /* verilator lint_on BLKSEQ */
                end else begin
                    // ============================================================
                    // Round-Robin Priority Scheme
                    // ============================================================
                    // Start checking from priority_ptr and cycle downward
                    // This ensures fair rotation of priority
                    /* verilator lint_off BLKSEQ */
                    granted = 0;  // No grant issued yet
                    
                    // Check all ports starting from priority_ptr, cycling downward
                    for (i = 0; i < NUM_PORTS; i = i + 1) begin
                        // Calculate port index: start from priority_ptr and go down
                        // Modulo arithmetic handles wrap-around
                        check_idx = (priority_ptr - i + NUM_PORTS) % NUM_PORTS;
                        
                        // If this port is requesting and we haven't granted yet, grant it
                        if (request[check_idx] && !granted) begin 
                            grant[check_idx] <= 1'b1;  // Grant this port
                            granted = 1;                // Mark that we've granted
                            // Update priority pointer: next cycle starts from port before this one
                            // This implements the round-robin rotation
                            priority_ptr <= (check_idx - 1 + NUM_PORTS) % NUM_PORTS; 
                        end
                    end
                    /* verilator lint_on BLKSEQ */
                end
            end
        end
    end

endmodule