Prioriteits-encoder - Priority encoder

Een prioriteits-encoder is een circuit of algoritme dat meerdere binaire ingangen comprimeert tot een kleiner aantal uitgangen. De uitvoer van een prioriteits-encoder is de binaire weergave van het oorspronkelijke getal, beginnend bij nul van het meest significante invoerbit. Ze worden vaak gebruikt om onderbrekingsverzoeken te controleren door te handelen op de onderbrekingsinvoer met de hoogste prioriteit.

Een 4:2 Priority Encoder

Als twee of meer ingangen tegelijkertijd worden gegeven, heeft de ingang met de hoogste prioriteit voorrang . Een voorbeeld van een enkele bit 4 tot 2 encoder wordt getoond, waarbij de ingangen met de hoogste prioriteit links staan ​​en "x" een irrelevante waarde aangeeft - dwz elke invoerwaarde daar levert dezelfde uitvoer op, omdat deze wordt vervangen door invoer met een hogere prioriteit. De uitgang V geeft aan of de ingang geldig is.

Prioriteits-encoders kunnen eenvoudig in arrays worden aangesloten om grotere encoders te maken, zoals één 16-naar-4-encoder gemaakt van zes 4-naar-2 prioriteits-encoders - vier 4-naar-2-encoders waarvan de signaalbron is aangesloten op hun ingangen, en de twee overige encoders nemen de output van de eerste vier als input. De prioriteit codeerinrichting is een verbetering van een eenvoudige codeerschakeling, wat het verwerken mogelijke ingang configuraties .

Recursieve constructie van prioriteits-encoders

Een prioriteits-encoder, ook wel voorloopnuldetector (LZD) of voorloopnulteller (LZC) genoemd, ontvangt een -bit ingangsvector en detecteert de index van de eerste binaire '1' in de ingangsvector. Een geldig signaal geeft aan of er een binaire '1' is gedetecteerd in de invoervector, dus de index is geldig. ${\displaystyle n}$

Prioriteit-encoders kunnen efficiënt worden geconstrueerd door recursie. De invoervector wordt met bits in gelijke fragmenten gesplitst . Voor elk fragment wordt een prioriteits-encoder met een smallere breedte van 𝑛/𝑘 toegepast. Het geldige bit van elk van de 's gaat naar een bit om het eerste geldige fragment te detecteren. De locatie van dit fragment is het hogere deel van de totale index en stuurt de exacte locatie binnen het fragment zelf om het onderste deel van de totale index te produceren. ${\displaystyle k}$${\displaystyle n/k}$${\displaystyle {\textrm {PE}}_{n/k}}$${\displaystyle k}$ ${\displaystyle {\textrm {PE}}_{n/k}}$${\displaystyle k}$${\displaystyle {\textrm {PE}}_{n/k}}$

De diepte van de voorgestelde structuur is , terwijl de complexiteit van het hardwaregebied is . Als Altera's Stratix V of gelijkwaardig apparaat wordt gebruikt, wordt aanbevolen om hogere prestaties en gebiedscompressie te bereiken, aangezien de mux kan worden geïmplementeerd met behulp van 6-LUT, dus een volledige ALM. ${\displaystyle \lceil \log _{k}n\rceil}$${\displaystyle {\mathcal {O}}(n)}$${\displaystyle k=4}$

Een open-source Verilog-generator voor de recursieve prioriteit-encoder is online beschikbaar.

Prioriteit-encoder (links) symbool (rechts) recursieve definitie.

Een gedragsbeschrijving van de prioriteits-encoder in Verilog is als volgt.

// behavioural description of priority enconder;
// https://github.com/AmeerAbdelhadi/Indirectly-Indexed-2D-Binary-Content-Addressable-Memory-BCAM

module pe_bhv
 #( parameter                   OHW = 512 ) // encoder one-hot input width
  ( input                       clk       , // clock for pipelined priority encoder
    input                       rst       , // registers reset for pipelined priority encoder
    input      [      OHW -1:0] oht       ,  // one-hot input  / [      OHW -1:0]
    output reg [`log2(OHW)-1:0] bin       ,  // first '1' index/ [`log2(OHW)-1:0]
    output reg                  vld       ); // binary is valid if one was found
    
  // use while loop for non fixed loop length
  // synthesizable well with Intel's QuartusII
  always @(*) begin
    bin = {`log2(OHW){1'b0}};
    vld = oht[bin]         ;
    while ((!vld) && (bin!=(OHW-1))) begin
      bin = bin + 1 ;
      vld = oht[bin];
    end
  end

endmodule

Eenvoudige encoder

Een eenvoudige 4:2 Encoder met OR-poort.

Een eenvoudig encodercircuit is een een-heet naar binair omzetter. Dat wil zeggen, als er 2 ⁿ invoerlijnen zijn, en hoogstens één daarvan zal ooit hoog zijn, wordt de binaire code van deze 'hot' lijn geproduceerd op de n- bits uitvoerlijnen.

Referenties