1

我来自软件领域，并试图找出如何在 VHDL 中编写顺序算法。从教科书中，它说进程内的语句是按顺序执行的。但我意识到只有当涉及到变量而不是信号时，它才是正确的。进程内部的 Re 信号，它们在进程结束时得到更新，并且评估使用右操作数的先前值。所以据我了解，它仍然是并发的。出于性能目的，我不能总是使用变量来进行复杂的计算。

  1. 但是如何使用信号来呈现顺序算法呢？我最初的想法是使用 FSM。真的吗？FSM 是在 VHDL 中正确编码顺序算法的唯一方法吗？
  2. 如果我是对的，进程中的信号语句是并发的，那么这与体系结构级别的信号并发分配有什么区别？过程的顺序性是否只适用于变量赋值？
4

2 回答 2

4

当您尝试在不同的周期中执行算法的步骤时，您已经意识到流程中的“顺序”结构本身并不能做到这一点 - 事实上，变量也无济于事。一个顺序程序——除非它使用明确的“等待某个事件”，例如等待上升沿（clk）——将被展开并在单个时钟周期内执行。

正如您可能已经发现使用变量一样，这可能是一个相当长的时钟周期。

VHDL中有三种主要的顺序执行方式，用途不同。

让我们尝试他们在 a 和 b 之间实现线性插值，

a, b, c, x : unsigned(15 downto 0);
x <= ((a * (65536 - c)) + (b * c)) / 65536;

(1) 是经典的状态机；最好的形式是单进程 SM。在这里，计算被分解为几个周期，以确保一次最多进行一个乘法（乘法器很昂贵！），但 C1 是并行计算的（加法/减法很便宜！）。它可以安全地用变量而不是中间结果的信号重写。

type state_type is (idle, step_1, step_2, done);
signal state     : state_type := idle;
signal start     : boolean := false;
signal c1        : unsigned(16 downto 0); -- range includes 65536!
signal p0, p1, s : unsigned(31 downto 0);

process(clk) is
begin
   if rising_edge(clk) then
      case state is
      when idle   => if start then
                        p1    <= b * c;
                        c1    <= 65536 - c;
                        state <= step_1;
                     end if;
      when step_1 => P0 <= a * c1;
                     state <= step_2;
      when step_2 => s <= p0 + p1;
                     state <= done;
      when done   => x <= s(31 downto 16);
                     if not start then  -- avoid retriggering
                        state <= idle;  
                     end if;
      end case;
   end if;
end process;

（2）是马丁汤普森（优秀文章！）链接的“隐式状态机”......编辑添加链接，因为马丁的答案消失了。与显式状态机相同的注释适用于它。

process(clk) is
begin
   if start then
      p1 <= b * c;
      c1 <= 65536 - c;
      wait for rising_edge(clk);
      p0 <= a * c1;
      wait for rising_edge(clk);
      s  <= p0 + p1;
      wait for rising_edge(clk);
      x  <= s(31 downto 16);
      while start loop
         wait for rising_edge(clk);
      end loop;
   end if;
end process;

(3) 是流水线处理器。在这里，执行需要几个周期，但一切都是并行发生的！流水线的深度（以周期为单位）允许每个逻辑顺序步骤以顺序方式发生。这允许高性能，因为长链计算被分解成周期大小的步骤......

    signal start     : boolean := false;
    signal c1        : unsigned(16 downto 0); -- range includes 65536!
    signal pa, pb, pb2, s : unsigned(31 downto 0);
    signal a1        : unsigned(15 downto 0);

process(clk) is
begin
   if rising_edge(clk) then
      -- first cycle
      pb <= b * c;
      c1 <= 65536 - c;
      a1 <= a;     -- save copy of a for next cycle
      -- second cycle
      pa <= a1 * c1;  -- NB this is the LAST cycle copy of c1 not the new one!
      pb2 <= pb;   -- save copy of product b
      -- third cycle
      s  <= pa + pb2;
      -- fourth cycle
      x  <= s(31 downto 16);
   end if;
end process;

在这里，资源不共享；它将使用 2 个乘法器，因为每个时钟周期有 2 个乘法器。它还将为中间结果和副本使用更多的寄存器。但是，给定每个周期中 a、b、c 的新值，它会在每个周期中输出一个新结果——从输入延迟四个周期。

于 2013-02-05T16:51:26.797 回答
1

  1. 大多数多周期算法可以通过使用您建议的 FSM 或使用流水线逻辑来实现。如果算法由严格的顺序步骤（即没有循环）组成，流水线逻辑可能是更好的选择，FSM 通常只用于需要根据输入不同控制流的更复杂的算法。

    流水线逻辑实际上是一个非常长的组合逻辑链，使用寄存器分成多个“阶段”，数据从一个阶段流向下一个阶段。添加寄存器以减少每个阶段（两个寄存器之间）的延迟，以增加延迟为代价允许更高的时钟频率。但是请注意，较高的延迟并不意味着较低的吞吐量，因为新数据可以在前一个数据项完成之前开始处理！对于 FSM，这通常是不可能的。

  2. 进程内的信号分配与体系结构之间的最大区别在于，您可以在进程内的多个位置为信号分配一个值，最后一个分配“获胜”。在架构级别，一个信号只能有一个赋值语句。许多控制流语句（if、case/when 等）也只能在流程中使用，而不是在体系结构级别。

于 2013-02-04T16:56:27.127 回答