2016-07-29 23 views
1

Ich habe ein Array/Vektor und ich möchte ein neues Array durch Verarbeitung der ersten generieren. Ein einfaches Beispiel für das, was ich brauche, ist, dass jedes i-te Element des neuen Arrays die Summe der Elemente i-1, i und i + 1 von der ersten ist. Ich weiß, dass dies sehr einfach in einer sequentiellen Weise durch Iterieren durch das Array getan werden kann. Ich wanderte, wenn es irgendeine Art von Ausdruck gab, der dies generalisierte und dies zu einer Paralleloperation machte (wie in Mathe: neu [i]: = alt [i - 1] + alt [i] + alt [i + 1] , wobei i (1, n)).verallgemeinerte Aggregat in VHDL

+0

Schreiben Sie eine Funktion, die das initialisierte Array zurückgibt. –

+0

In einem Kommentar haben Sie die Absicht ausgedrückt, mit 1000 oder mehr Elementen umzugehen, wobei die Anzahl und die Elementgröße die Implementierung in einem FPGA mit endlicher Ressource und nicht passen. Sie haben nicht angegeben, wie viele Elemente noch ihre Größe und das sagt uns Ihre Frage ist unklar. Theoretische Fragen ohne vollständige Parameter können wahrscheinlich keine brauchbaren Antworten erhalten. Es kann einen Kompromiss zwischen Zeit und Komplexität geben, bei dem Sie weniger Ressourcen über eine bestimmte Anzahl von Takten verwenden können, um die Funktion zu vervollständigen. – user1155120

Antwort

0

Da Ihre Frage nach Parallelität geht, gehe ich davon aus, dass Sie an der Hardware interessiert sind, die aus Ihrer VHDL-Beschreibung und nicht aus der Simulation synthetisiert wird.

Parallelität ist eine Frage von , wenn alle diese Ergänzungen stattfinden? Wenn Ihr Design synchron ist - sagen wir mal von der ansteigenden Flanke eines Takt clk genannt - dann:

subtype word: unsigned(7 downto 0); 
type word_array is array(natural range <>) of word; 
signal a: word_array(0 to 15); 
signal b: word_array(1 to 14); 
... 
process(clk) 
begin 
    if rising_edge(clk) then 
    for i in 1 to 14 loop 
     b(i) <= a(i - 1) + a(i) + a(i + 1); 
    end loop; 
    end if; 
end process; 

die 14 Werte in Array b an jeder ansteigenden Flanke des Takt parallel berechnen wird. Und es werden so viele 8-Bit-Addierer wie nötig instanziiert, um dies zu tun. Die Frage ist nicht, ob Sie eine for Schleife oder etwas anderes verwenden, ist es wirklich Wann finden diese Operationen statt? Die Antwort ist in der Beschreibung: während der gleichen Taktperiode.

könnten Sie überlasten den "+" Operator auf Vektoren zu arbeiten:

function "+"(a, b: word_array) return word_array is 
    constant n: positive := a'length; 
    variable va: word_array(0 to n - 1) := a; 
    variable vb: word_array(0 to n - 1) := b; 
    variable sum: word_array(0 to n - 1); 
begin 
    if n = 1 then 
    sum(0) := va(0) + vb(0); 
    else 
    sum := (va(0 to n/2 - 1) + vb(0 to n/2 - 1)) & 
      (va(n/2 to n - 1) + vb(n/2 to n - 1)); 
    end if; 
    return sum; 
end function "+"; 

und es verwenden, um offenbar eine parallele Beschreibung schreiben:

process(clk) 
begin 
    if rising_edge(clk) then 
    b <= a(0 to 13) + a(1 to 14) + a(2 to 15); 
    end if; 
end process; 

aber es würde keinen Unterschied machen, und die Die resultierende Hardware wäre die gleiche.

Sie könnten auch eine generieren verwenden Anweisung, das gleiche zu tun:

g: for i in 1 to 14 generate 
    process(clk) 
    begin 
    if rising_edge(clk) then 
     b(i) <= a(i - 1) + a(i) + a(i + 1); 
    end if; 
    end process; 
end generate g; 

aber auch hier wäre es keinen Unterschied für den Synthesizer machen.