Come viene implementato il numero intero senza segno massimo nell'hardware?

10

Sto lavorando a un progetto che coinvolge molte funzioni max (e funzioni max come argomenti per altre funzioni max).

Nel tentativo di semplificare la progettazione dell'hardware, mi chiedevo come max è implementato nell'hardware?

Matematicamente, Max (a, b) può essere rappresentato come [(a + b) + abs (b - a)] / 2.

È così che viene implementato nell'hardware? (ad es. in fasi; addizione, divisione bit shift, ecc.)

In tal caso, come viene calcolato l'assoluto della differenza?

digital-logic

— Giacomo
fonte

10

Un approccio molto semplice sarebbe quello di implementare (a> b)? A: b. a> b può essere implementato partendo da sinistra e verificando ogni coppia di bit di (a, b):

entrambi 0 o entrambi 1: continua alla coppia inferiore successiva
a è 1: a è il più alto; b è 1: b è il più alto

Quando sai qual è il più alto puoi selezionarlo con un mux 2N-> N.

Con qualche trucco intelligente, il controllo delle coppie di bit può essere combinato con il muxer per la stessa coppia di bit.

— Wouter van Ooijen
fonte

2

Vediamo l'algoritmo nella domanda:

[(a + b) + abs(b - a)]/2

Questo ha una fase di addizione e sottrazione che viene quindi alimentata con una seconda fase. La divisione per 2 è banale nell'hardware, può essere fatto rimuovendo l'LSB. Tuttavia, il sommatore / sottrattore completo a due stadi è piuttosto lento e ad alta intensità di gate, specialmente se si stanno collegando a cascata più caparison come te.

Basandosi sulla risposta di Wouter van Ooijen, la struttura generalizzata è un comparatore digitale che alimenta il segnale selezionato di un mux:

schematico

^{simula questo circuito - Schema creato usando CircuitLab}

Lo schema sopra è per:

(A > B) ? A : B

ma si noti che può essere facilmente riconfigurato per qualsiasi confronto tra i due ingressi effettuando connessioni logiche diverse tra le uscite del comparatore e la selezione mux.

Quindi, se sappiamo come formulare le tre uscite dal comparatore, possiamo implementare qualsiasi confronto nell'hardware. La logica del comparatore è ben descritta qui . Per ottimizzare l'hardware, rimuoveremmo semplicemente la logica che guida le uscite del comparatore inutilizzate.

Ma alla fine, se sta andando all'hardware, deve passare attraverso la sintesi. Quindi non dovresti ossessionarti su quale schema a livello di gate sia ottimale. Invece, ottimizza il tuo codice e algoritmi in modo che almeno non stai forzando il sintetizzatore a produrre un risultato inefficiente. "Con qualche accorgimento intelligente il controllo delle coppie di bit può essere combinato con il muxer per la stessa coppia di bit", e il modo più semplice per eseguire questa ottimizzazione è con la sintesi.

— travisbartley
fonte

1

Se vuoi davvero costruire un circuito specializzato per calcolare il massimo, puoi iniziare con un blocco di base con le seguenti equazioni:

\begin{array}{rcl} E_{io, o u t} & \leftarrow & E_{io, io n} \land \neg ({un'}_{io} \oplus B_{io}) \\ L_{io, o u t} & \leftarrow & (\neg E_{io, io n} \land L_{io, io n}) \lor (E_{io, io n} \land {un'}_{io} \land \neg B_{io}) \\ r_{io} & \leftarrow & (\neg E_{io, io n} \land ((L_{io, io n} \land {un'}_{io}) \lor (\neg L_{io, io n} \land B_{io}))) \lor (E_{io, io n} \land ({un'}_{io} \lor B_{io})) \end{array}

$\begin{eqnarray} E_{i,out} &\leftarrow& E_{i,in} \wedge \neg (a_i \oplus b_i) \\ L_{i,out} &\leftarrow& (\neg E_{i,in} \wedge L_{i,in})\vee (E_{i,in} \wedge a_i \wedge \neg b_i)\\ r_i &\leftarrow& (\neg E_{i,in} \wedge ((L_{i,in} \wedge a_i) \vee (\neg L_{i,in} \wedge b_i))) \vee (E_{i,in} \wedge (a_i \vee b_i)) \end{eqnarray}$

e quindi collegarli con la cifra più significativa che alimenta quella successiva. La parte critica va dall'MSB all'LSB mentre il circuito basato sulla sottostrazione avrà nella migliore delle ipotesi un percorso critico che va dall'LSB all'MSB e poi di nuovo all'LSB.

È l'equivalente di un sommatore carry-ripple. Se sei interessato, puoi creare l'equivalente per gli additivi carry-save o carry-select.

$E$ $L$ $\neg E$ $a$

— AProgrammer
fonte