Bits aus Vektor maskieren und verschieben

[MemY (Gast)]

Hallo,

hat jemand einen Tipp, wie ich interaktiv maskierte Bits aus einem 
Vektor (INPUTDATA) neu angeordnet, durch Verschiebung, in ein Vektor 
(MASK0_N_0_TEMP_SRL) packen kann? Unten habe ich euch ein Beispiel:

Eingangsdaten:                 01010101110 -- INPUTDATA
Maske:                         00001111000 -- MASK0
Durch Maske gewählte Daten:    00000101000 -- MASK0_N_0_TEMP
Gewählte Daten verschieben:    00000000101 -- MASK0_N_0_TEMP_SRL

Das Problem ist, dass nicht nur die Input Daten, sodern auch die Maske 
variabel ist. So könnte ein Beispiel auch so aussehen:

Eingangsdaten:                01110111100 -- INPUTDATA
Maske:                        00011111110 -- MASK0
Durch Maske gewählte Daten:   00010111100 -- MASK0_N_0_TEMP
Gewählte Daten verschieben:   00001011110 -- MASK0_N_0_TEMP_SRL


Mein Ansatz:

-- Maskierung der Eingangsdaten
process(CLK, syn_n_reset)
begin
  if(syn_n_reset = '0') then
    MASK0_N_0_TEMP <= (others => '0');
  elsif rising_edge(CLK) then
    MASK0_N_0_TEMP <= INPUTDATA and MASK0;
  end if;
end process;

-- suche Anfang der Maske und verschiebe um Anzahl der Stellen bis zum ersten gesetzten Bit der Maske
process(CLK, syn_n_reset)
begin
  if rising_edge(CLK) then
    for i in 0 to MASK0'length loop
      if (MASK0(i) = '1') then
        MASK0_N_0_TEMP_SRL <= MASK0_N_0_TEMP SRL i;
      end if;
    end loop;
  end if;
end process;

Hat jemand eine bessere Idee oder einen besseren Ansatz dazu?

Grüße
MemY

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

MemY schrieb:
> Das Problem ist, dass nicht nur die Input Daten, sodern auch die Maske
> variabel ist.
Das gibt so erst mal einen Monstermultiplexer...

Must du diese Rechenoperation pro Wort in 1 Taktzyklus erledigen? Oder 
hast du da evtl. ein wenig Zeit?

[MemY (Gast)]

Hallo Lothar,

danke für die Antwort.

Ich haette eig. schon ein paar Takte Zeit...

Ich habe es im Moment mit einer riesigen CASE-Anweisung (also einem MUX) 
realisiert. Mit einem kleinen Zähler schaue ich an welcher Bitposition 
die Maske beginnt, danach wird geeignet verschoben.

if (MASK0(Bit_CTR) = '1') then
CASE Bit_CTR IS
WHEN 0 => MASK0_N_0_TEMP_SRL(47 downto 0) <= MASK0_N_0_TEMP(47 downto 0);
WHEN 1 => MASK0_N_0_TEMP_SRL(46 downto 0) <= MASK0_N_0_TEMP(47 downto 1);
WHEN 2 => MASK0_N_0_TEMP_SRL(45 downto 0) <= MASK0_N_0_TEMP(47 downto 2);
WHEN 3 => MASK0_N_0_TEMP_SRL(44 downto 0) <= MASK0_N_0_TEMP(47 downto 3);
.
.
.
WHEN 46 => MASK0_N_0_TEMP_SRL(1 downto 0) <= MASK0_N_0_TEMP(47 downto 46);
WHEN 47 => MASK0_N_0_TEMP_SRL(0) <= MASK0_N_0_TEMP(47);
WHEN OTHERS => Bit_CTR := Bit_CTR - Bit_CTR;
END CASE;
else
Bit_CTR := Bit_CTR + 1;
end if;

Viele Grueße MemY

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

MemY schrieb:
> Ich haette eig. schon ein paar Takte Zeit...
Dann würde ich das mit einer FSM und einem Schieberegister lösen:
1. Ausmaskieren und das Schieberegister laden
2. mit jedem Takt einmal schieben, bis eine 1 am LSB ankommt

[MemY (Gast)]

Lothar Miller schrieb:
> 2. mit jedem Takt einmal schieben, bis eine 1 am LSB ankommt

Das wuerde bedeuten, dass die Maske und die maskierten Daten in jeweils 
ein Schieberegister hineingetaktet werden muesste?

[Falk B. (falk)]

Ja.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

MemY schrieb:
> Das wuerde bedeuten, dass die Maske und die maskierten Daten in jeweils
> ein Schieberegister hineingetaktet werden muesste?
Kann man so machen. Ich würde aber eher das Schieberegister mit dem 
maskierten Vektor laden. Und dieses "Zwischenergebnis" shiften. Dann ist 
nur 1 Schieberegister beteiligt. Du hast es selber schon so 
aufgezeichnet:
> Eingangsdaten: 01110111100 -- INPUTDATA
> Maske: 00011111110 -- MASK0
> Durch Maske gewählte Daten: 00010111100 -- MASK0_N_0_TEMP
---> dieses Zwischenergebnis kommt ins Schieberegister
Und dann werden die Daten geschoben:
> Gewählte Daten verschieben: 00001011110 -- MASK0_N_0_TEMP_SRL

[Falk B. (falk)]

@ Lothar Miller (lkmiller) (Moderator) Benutzerseite

>Kann man so machen. Ich würde aber eher das Schieberegister mit dem
>maskierten Vektor laden. Und dieses "Zwischenergebnis" shiften.

Geht nicht, denn das maskierte LSB kann auch 0 sein.
Man braucht 2 Schieberegister.
Aber im Zeitalter der Multimilliongates-FPGAs sind 24 FlipFlops weiß 
Gott zu verschmerzen ;-)
Und vielleicht noch ne Handvoll Dollar, ähh FlipFlops für die state 
machine.

[Falk B. (falk)]

So könnte es gehen, 39 FlipFlops, des Synthesizer packt noch 3 
obendrauf, damit es schneller wird.

[Schlumpf (Gast)]

Eine andere Alternative, wenn es sehr schnell sein soll, wäre eine 
parallele Verarbeitung. Allerdings entsteht dabei eine Monsterlogik

Du bestimmst erst die Position der ersten "1" der Maske parallel:

pos <= 0 when mask(0)          = '1'          else
       1 when mask(1 downto 0) = "10"         else
       2 when mask(2 downto 0) = "100"        else
       3 when mask(3 downto 0) = "1000"       else
       .....
       n when mask(n downto 0) = "100...0";

Diesen wert von pos verwendest du dann, um einen Slice aus dem 
Ergebnisvektor nach der Maskierung herauszuschneiden und Richtung MSB 
hin mit Nullen aufzufüllen.
n sei dabei die größe der Vektoren (n downto 0)

ergebnis(n-pos downto 0) <= maskierter_vektor(n downto pos);
ergebnis(n downto n+1-pos) <= (others => '0');

also so:
Position:                      n         0
Eingangsdaten:                 01010101110
Maske:                         00001111000
Durch Maske gewählte Daten:    00000101000
Position:                   n         0
herausgeschnittene Daten:   00000000101

Ressourcenschonend ist das nicht gerade, aber vollkommen parallel und 
somit ganz ohne einen Takt möglich.

Hoff, ich hab keinen Denkfehler drin ;-)

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Falk Brunner schrieb:
>> dieses "Zwischenergebnis" shiften.
> Geht nicht, denn das maskierte LSB kann auch 0 sein.
Richtig, ich hatte das falsch verstanden:
MemY schrieb:
> bis zum ersten gesetzten Bit der Maske

Falk Brunner schrieb:
> So könnte es gehen
Man könnte den Sonderfall "Maske ist komplett null" aber auchvorneweg 
abfragen. Letztlich spart man sich aber nichts, weil dieser Vergleich 
mehr Logik braucht (siehe Anhang)...

> 39 FlipFlops
Lass die Registrierung vom result raus, dann sinds weniger... ;-)

[MemY (Gast)]

Zuerst mal vielen Dank für die vielen nuetzlichen Hinweise von euch!

Habe nun den maskshift von Lothar für meine Beduerfnisse angepasst und 
simuliert und es scheint soweit alles gut zu gehen!


Gruß MemY

[Falk B. (falk)]

@ MemY (Gast)

>Habe nun den maskshift von Lothar für meine Beduerfnisse angepasst und

Der hat gegutenbergt!!! ;-)

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Falk Brunner schrieb:
> Der hat gegutenbergt!!!
Das war doch nur gegutenborgt oder eher gutgeborgt... ;-)

[Schlumpf (Gast)]

Ich habe gerade mal zum Spass den von mir gemachten Vorschlag durch die 
Synthese geschickt:

ARCHITECTURE arch OF mask_and_shift IS
   signal position : integer range 0 to 10;
   signal mask_vektor : std_logic_vector(10 downto 0);
BEGIN
   mask_vektor <= in_val AND mask;
   position <= 0 when mask(0)          = '1'            else
               1 when mask(1 downto 0) = "10"           else
               2 when mask(2 downto 0) = "100"          else
               3 when mask(3 downto 0) = "1000"         else
               4 when mask(4 downto 0) = "10000"        else
               5 when mask(5 downto 0) = "100000"       else
               6 when mask(6 downto 0) = "1000000"      else
               7 when mask(7 downto 0) = "10000000"     else
               8 when mask(8 downto 0) = "100000000"    else
               9 when mask(9 downto 0) = "1000000000"   else
              10 when mask(10 downto 0)= "10000000000";
   process(mask_vektor, position)
   begin
     ergebnis((10-position) downto 0) <= mask_vektor(10 downto position);
     ergebnis(10 downto (11-position)) <= (others => '0');
   end process;
END arch;

Benötigt 148 LUT4 und ist abzüglich der PAD-Delays in 12ns durch..
Hätte schlimmer kommen können gg

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Schlumpf schrieb:
> Benötigt 148 LUT4
Auf einem S3 sinds nur 120... ;-)

> Hätte schlimmer kommen können
Und es kam schlimmer:

Macro Statistics
# Latches           :  11

Aber der Ansatz scheint vielversprechend, und ich habe ihn mal 
verschlankt:

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity mask_shift_par is
    Port ( data : in  STD_LOGIC_VECTOR (10 downto 0);
           mask : in  STD_LOGIC_VECTOR (10 downto 0);
           result : out  STD_LOGIC_VECTOR (10 downto 0));
end mask_shift_seq;

architecture Behavioral of mask_shift_par is
   signal mv : std_logic_vector(10 downto 0);
BEGIN
   mv <= data AND mask;
   result <=                  mv(10 downto 0)  when mask(0) = '1' else
             "0"           &  mv(10 downto 1)  when mask(1) = '1' else
             "00"          &  mv(10 downto 2)  when mask(2) = '1' else
             "000"         &  mv(10 downto 3)  when mask(3) = '1' else
             "0000"        &  mv(10 downto 4)  when mask(4) = '1' else
             "00000"       &  mv(10 downto 5)  when mask(5) = '1' else
             "000000"      &  mv(10 downto 6)  when mask(6) = '1' else
             "0000000"     &  mv(10 downto 7)  when mask(7) = '1' else
             "00000000"    &  mv(10 downto 8)  when mask(8) = '1' else
             "000000000"   &  mv(10 downto 9)  when mask(9) = '1' else
             "0000000000"  &  mv(10 downto 10) when mask(10)= '1' else
             "00000000000";
END Behavioral;

Fazit:
Number of 4 input LUTs     62
Number of occupied Slices  33

[Schlumpf (Gast)]

Lothar Miller schrieb:
> Auf einem S3 sinds nur 120... ;-)

Angeber ;-)

Lothar Miller schrieb:
> Und es kam schlimmer:Macro Statistics
> # Latches           :  11

Stimmt.. Bei mir waren es "combinatorial loops", aber das ist genauso 
bescheiden. Das Design von mir ist bei genauerem Hinsehen wirklich nicht 
ganz hasenrein...

Lothar Miller schrieb:
> und ich habe ihn mal
> verschlankt:

Sehr elegant.. und eigentlich so naheliegend :-)