priority_encoder.v

/**
 * Priority Encoder
 * 
 * This module implements a priority encoder that finds the highest-priority
 * active bit in the input vector. Higher bit indices have higher priority.
 * 
 * Key Features:
 * - Priority encoding: Highest active bit index is encoded
 * - Valid flag: Indicates if any input bit is active
 * - Configurable width: Any input width via WIDTH parameter
 * - Combinational: Outputs available in same cycle as inputs
 * 
 * Operation:
 * - Scans input from MSB (highest index) to LSB (lowest index)
 * - Encodes the index of the first (highest priority) active bit found
 * - Sets valid flag if any bit is active
 * - If no bits active: out = 0, valid = 0
 * 
 * Priority Order:
 * - Bit [WIDTH-1] has highest priority
 * - Bit [0] has lowest priority
 * - If multiple bits are active, highest index wins
 * 
 * Use Cases:
 * - Interrupt controllers (highest priority interrupt)
 * - Arbitration (highest priority request)
 * - One-hot to binary conversion (with priority)
 * - Address encoding in CAMs
 * 
 * @param WIDTH Width of input vector (default: 8 bits)
 * @param OUT_WIDTH Width of output (calculated as log2(WIDTH))
 * 
 * @input in[WIDTH-1:0] Input vector (one-hot or sparse)
 * @output out[OUT_WIDTH-1:0] Encoded index of highest priority active bit
 * @output valid High when at least one input bit is active
 */
module priority_encoder #(
    parameter WIDTH = 8,
    parameter OUT_WIDTH = $clog2(WIDTH)
) (
    input wire [WIDTH-1:0] in,
    output reg [OUT_WIDTH-1:0] out,
    output reg valid
);

    // ============================================================================
    // Priority Encoding Logic
    // ============================================================================
    // Combinational logic: outputs available immediately based on inputs
    integer i;  // Loop counter
    
    always @(*) begin
        // ========================================================================
        // Initialize Outputs
        // ========================================================================
        // Default: no active bit found
        valid = 0;
        out = {OUT_WIDTH{1'b0}};
        
        // ========================================================================
        // Priority Search
        // ========================================================================
        // Search from MSB (highest index) to LSB (lowest index)
        // First active bit found has highest priority
        for (i = WIDTH-1; i >= 0; i = i - 1) begin
            if (in[i]) begin
                // ================================================================
                // Active Bit Found
                // ================================================================
                // Encode the index of this bit
                out = i[OUT_WIDTH-1:0];
                // Set valid flag to indicate an active bit was found
                valid = 1;
                // Break the loop by setting i to -1
                // This ensures we only encode the highest priority (first found) bit
                i = -1;
            end
        end
        // Note: If loop completes without finding active bit, outputs remain at defaults
    end

endmodule