Shift von Pipeline Elementen

[Patrick B. (p51d)]

Hallo

Ich möchte eine einfache Division erreichen. Sprich am Shift-Eingang 
leigt 2 an, dann sollen die Daten um 2 Bits nach rechst verschoben 
ausgegeben werden.
Ich dachte mir, dass man das über eine For-Schleife lösen könnte:

type pipeline_array is array(0 to MAX_SHIFTS-1) of std_logic_vector(DATA_WIDTH-1 downto 0);
signal pipeline : pipeline_array;

divide : process(clk)
begin
  if rising_edge(clk) then
    if reset = '1' then
      for i in 0 to (MAX_SHIFTS-1) loop
        pipeline(i) <= (others => '0');
      end loop;
    else
      for i in 0 to (MAX_SHIFTS-1) loop
        if ce = '1' then
          if std_logic_vector(to_unsigned(i, SHIFT_WIDTH)) < i_shifts then
            pipeline(i+1) <= '0' & pipeline(i)(DATA_WIDTH-1 downto 1);
          else
            pipeline(i+1) <= pipeline(i);
          end if;
        end if;        
      end loop;
    end if;
  end if;
end process;

Das Modul hätte eine konstate Verzögerung. Für jedes Element soll anhand 
des i_shift Eingangs entschieden werden, ob nochmals geschoben werden 
soll, oder ob die nächste Stufe das Ergebnis direkt übernehmen soll.

Fehlermeldungen bekomme ich keine, aber leider stoppt der Simulator beim 
ersten "gültigen" Takt. Sieht jemand den Fehler? Oder gibts eine 
einfachere Lösung für die Division als Schiebeoperation, die vom Eingang 
abhängig ist?

Die IP Cores für Radix-2 sind für mich viel zu umfangreich (da ich nur 
eine 2^n Division brauche).

Besten Dank,
Gruss
Patrick

EDIT:
Hab den Fehler für das Stoppen des Simulators gefunden. Die For-Schleife 
darf natürlich nur bis (MAX_SHIFTS-2) gehen, ansonsten gibts einen 
fehlerhaften Zugriff.

[Markus F. (Gast)]

Das kann man so nur lösen, wenn man alle erdenklichen Versionen der 
Shift-Operation ausformuliert und dann die richtige real selektiert. Es 
muss ja real alles möglich sein, was vorkommen kann. So macht man sowas 
aber nicht.

[Duke Scarring (Gast)]

Markus F. schrieb:
> Das kann man so nur lösen, wenn man alle erdenklichen Versionen der
> Shift-Operation ausformuliert und dann die richtige real selektiert. Es
> muss ja real alles möglich sein, was vorkommen kann. So macht man sowas
> aber nicht.
Doch. Mir ist das unter dem Namen Barrel-Shifter bekannt.

Duke

[Thomas R. (Firma: abaxor engineering) (abaxor)]

Duke Scarring schrieb:
> Markus F. schrieb:
>> Das kann man so nur lösen, wenn man alle erdenklichen Versionen der
>> Shift-Operation ausformuliert und dann die richtige real selektiert. Es
>> muss ja real alles möglich sein, was vorkommen kann. So macht man sowas
>> aber nicht.
> Doch. Mir ist das unter dem Namen Barrel-Shifter bekannt.

Nur gibt es die nicht in FPGAs, sie heißen jetzt DSP-Slices :-).

Mit einem 18x18 Multiplizierer kann man problemlos 0..18 Bit nach rechts 
schieben und das mit konstanter Latenz

Tom

[René D. (Firma: www.dossmatik.de) (dose)]

> Mit einem 18x18 Multiplizierer kann man problemlos 0..18 Bit nach rechts
> schieben und das mit konstanter Latenz
>
> Tom

Wieviele Takte braucht der Multiplizierer dafür?

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

René D. schrieb:
> Wieviele Takte braucht der Multiplizierer dafür?
Einen.
Oder andersrum: der Multiplizierer an sich braucht gar keinen. Aber er 
hat Register hinter sich...

[Duke Scarring (Gast)]

Lothar M. schrieb:
> Aber er
> hat Register hinter sich...
Die man durch Multiplexer umgehen kann.

Die Frage muss eher lauten: passt die Durchlaufzeit zur angepeilten 
Taktfrequenz.

Duke

[René D. (Firma: www.dossmatik.de) (dose)]

Duke Scarring schrieb:
> Markus F. schrieb:
>> Das kann man so nur lösen, wenn man alle erdenklichen Versionen der
>> Shift-Operation ausformuliert und dann die richtige real selektiert. Es
>> muss ja real alles möglich sein, was vorkommen kann. So macht man sowas
>> aber nicht.

Jetzt much ich dir auch mal wiedersprechen.

>  Mir ist das unter dem Namen Barrel-Shifter bekannt.
>
> Duke

Ich habe bei mir in der Mais-CPU eine Funktion, mit der in einem Takt 
geschiftet wird. Das habe ich vor langer Zeit geschrieben. Hatte auch 
lange gekonbelt.

  function shift_f
    (a          : in std_logic_vector(31 downto 0);
     b          : in std_logic_vector(31 downto 0);
     shift_func : in shift_function_type;
     rt_data    : in std_logic_vector(31 downto 0)) 
    return std_logic_vector
    
  is

    --barrel shifter unit
    variable shift1L, shift2L, shift4L, shift8L, shift16 :
      std_logic_vector(31 downto 0);
    variable shift1R, shift2R, shift4R, shift8R :
      std_logic_vector(31 downto 0);
    variable fills       : std_logic_vector(31 downto 16);
    variable shiftnumber : std_logic_vector(4 downto 0);
  begin

    if (shift_func(1) = '1' and rt_data(31) = '1') then
      fills := "1111111111111111";
    else
      fills := "0000000000000000";
    end if;

    if shift_func(2) = '0' then
      shiftnumber := b(10 downto 6);
    else
      shiftnumber := a(4 downto 0);
    end if;
    --SLL  rd<_rt << sa
    if shift_func (0) = '0' then        -- shift left
      if shiftnumber(0) = '1' then
        shift1L := rt_data(30 downto 0) & '0';
      else
        shift1L := rt_data;
      end if;
      if shiftnumber(1) = '1' then
        shift2L := shift1L(29 downto 0) & "00";
      else
        shift2L := shift1L;
      end if;
      if shiftnumber(2) = '1' then
        shift4L := shift2L(27 downto 0) & "0000";
      else
        shift4L := shift2L;
      end if;
      if shiftnumber(3) = '1' then
        shift8L := shift4L(23 downto 0) & "00000000";
      else
        shift8L := shift4L;
      end if;
      if shiftnumber(4) = '1' then
        shift16 := shift8L(15 downto 0) & X"0000";
      else
        shift16 := shift8L;
      end if;
      
    else                                --shift right
      if shiftnumber(0) = '1' then
        shift1R := fills(31) & rt_data(31 downto 1);
      else
        shift1R := rt_data;
      end if;
      if shiftnumber(1) = '1' then
        shift2R := fills(31 downto 30) & shift1R(31 downto 2);
      else
        shift2R := shift1R;
      end if;
      if shiftnumber(2) = '1' then
        shift4R := fills(31 downto 28) & shift2R(31 downto 4);
      else
        shift4R := shift2R;
      end if;
      if shiftnumber(3) = '1' then
        shift8R := fills(31 downto 24) & shift4R(31 downto 8);
      else
        shift8R := shift4R;
      end if;
      if shiftnumber(4) = '1' then
        shift16 := fills(31 downto 16) & shift8R(31 downto 16);
      else
        shift16 := shift8R;
      end if;
    end if;
    return(shift16);
    
  end shift_f;