Questa funzione di moltiplicazione matrice-vettore in VHDL è parallelizzata?

Ho la seguente funzione VHDL che moltiplica una data matrice mxn aper un vettore nx1 b:

function matrix_multiply_by_vector(a: integer_matrix; b: integer_vector; m: integer; n: integer)
return integer_vector is variable c : integer_vector(m-1 downto 0) := (others => 0);
begin
    for i in 0 to m-1 loop
        for j in 0 to n-1 loop
            c(i) := c(i) + (a(i,j) * b(j));
        end loop;
    end loop;
    return c;
end matrix_multiply_by_vector;

Funziona bene ma che cosa implementa effettivamente nell'hardware? In particolare, ciò che voglio sapere è se è abbastanza intelligente da capire che può parallelizzare il ciclo interno per, essenzialmente calcolando un prodotto punto per ogni riga della matrice. In caso contrario, qual è il modo più semplice (cioè una bella sintassi) per parallelizzare la moltiplicazione matrice-vettore?

In "hardware" (VHDL o Verilog) tutti i loop vengono srotolati ed eseguiti in parallelo.

Quindi non solo il tuo loop interno, ma anche il tuo loop esterno viene srotolato.

Questo è anche il motivo per cui la dimensione del loop deve essere conosciuta al momento della compilazione. Quando la lunghezza del loop è sconosciuta, lo strumento di sintesi si lamenterà.

È una trappola ben nota per i principianti che provengono da un linguaggio SW. Tentano di convertire:

int a,b,c;
   c = 0;
   while (a--)
     c +=  b;

All'hardware VHDL / Verilog. Il problema è che tutto funziona bene nella simulazione. Ma lo strumento di sintesi deve generare additivi: c = b+b+b+b...b;

Per questo lo strumento deve sapere quanti additivi creare. Se ava bene continuamente! (Anche se è 4.000.000. Si esaurirà le porte ma ci proverà!)

Ma se aè una variabile viene persa.

Questo codice parallelizzerà entrambi i loop, poiché non è stato definito un evento per controllare alcun sottoinsieme dell'elaborazione. I loop generano solo tutto l'hardware necessario per generare la funzione; hai bisogno di un PROCESSO .

Un processo ha un elenco di sensibilità che dice a VHDL (o al sintetizzatore) che il processo non viene invocato a meno che uno dei nodi nell'elenco non cambi. Questo può essere usato per sintetizzare i fermi ed espandersi oltre il regno della pura implementazione combinatoria.