1

我在 Virtex6 上有一段代码，可以一次汇总一堆东西。我继承了代码，它似乎比我想象的要困难一些，但有人告诉我这是快速总结事情的最佳方式。

基本上，如果我有一系列需要添加的值（比如其中 16 个），我们目前正在将它们添加为多个级别（summedOutput 和 addOverflow 是执行有符号加法和检测溢出的两个函数）：

    tmpSig_0_0 <= summedOutput(inSig_0, inSig_1);
    tmpSig_0_1 <= summedOutput(inSig_2, inSig_3);
    tmpSig_0_2 <= summedOutput(inSig_4, inSig_5);
    tmpSig_0_3 <= summedOutput(inSig_6, inSig_7);
    tmpSig_0_4 <= summedOutput(inSig_8, inSig_9);
    tmpSig_0_5 <= summedOutput(inSig_10, inSig_11);
    tmpSig_0_6 <= summedOutput(inSig_12, inSig_13);
    tmpSig_0_7 <= summedOutput(inSig_14, inSig_15);
    overflow_stage0 <= (| {overflow_input,additionOverflow(inSig_0,inSig_1,inSig_0+inSig_1),additionOverflow(inSig_2,inSig_3,inSig_2+inSig_3),additionOverflow(inSig_4,inSig_5,inSig_4+inSig_5),additionOverflow(inSig_6,inSig_7,inSig_6+inSig_7),additionOverflow(inSig_8,inSig_9,inSig_8+inSig_9),additionOverflow(inSig_10,inSig_11,inSig_10+inSig_11),additionOverflow(inSig_12,inSig_13,inSig_12+inSig_13),additionOverflow(inSig_14,inSig_15,inSig_14+inSig_15)});    

    tmpSig_1_0 <= summedOutput(tmpSig_0_0, tmpSig_0_1);
    tmpSig_1_1 <= summedOutput(tmpSig_0_2, tmpSig_0_3);
    tmpSig_1_2 <= summedOutput(tmpSig_0_4, tmpSig_0_5);
    tmpSig_1_3 <= summedOutput(tmpSig_0_6, tmpSig_0_7);
    overflow_stage1 <= (| {overflow_stage0, additionOverflow(tmpSig_0_0,tmpSig_0_1,tmpSig_0_0+tmpSig_0_1), additionOverflow(tmpSig_0_2,tmpSig_0_3,tmpSig_0_2+tmpSig_0_3), additionOverflow(tmpSig_0_4,tmpSig_0_5,tmpSig_0_4+tmpSig_0_5), additionOverflow(tmpSig_0_6,tmpSig_0_7,tmpSig_0_6+tmpSig_0_7)});

    tmpSig_2_0 <= summedOutput(tmpSig_1_0, tmpSig_1_1);
    tmpSig_2_1 <= summedOutput(tmpSig_1_2, tmpSig_1_3);
    overflow_stage2 <= (| {overflow_stage1, additionOverflow(tmpSig_1_0,tmpSig_1_1,tmpSig_1_0+tmpSig_1_1), additionOverflow(tmpSig_1_2,tmpSig_1_3,tmpSig_1_2+tmpSig_1_3)});

    outSig <= summedOutput(tmpSig_2_0, tmpSig_2_1);
    overflow <= (| {overflow_stage2, additionOverflow(tmpSig_2_0, tmpSig_2_1, tmpSig_2_0+tmpSig_2_1)});

有人告诉我，这将导致 4 个级别的添加（这是有道理的），并且比 16 个级别要好得多，如果我刚刚这样做的话：

outSig <= inSig_0 + inSig_1 + inSig_2 + inSig_3 .... inSig_14 + inSig_15;

我的问题是，如果我想扩展东西，这是一个非常手动的过程，而且不是很适应。有没有比我更聪明的方法呢？最好的办法是一系列基于参数大小添加内容的 for 循环，但我基本上会以上面的第二个示例结束，这可能非常深。

4

2 回答 2

2

现有代码（长代码）和您的单行解决方案之间的主要区别在于，现有代码被流水线化为 4 个时钟周期来计算结果，而您的单行解决方案声称在单个时钟周期中添加所有数字.

根据这些inSigs 的宽度，尝试一次将它们全部加起来可能不符合时机。您当然可以进行试验并用您的建议替换该代码，但是您应该尝试综合和 P&R 并查看您的时序报告是什么样的。如果它满足您所需的定时频率，那么您可以继续安全地更换您的解决方案。

或者，您可以尝试制作一个更浅的管道，这样会更干净（您可以在一个时钟周期中添加 4 个信号而不是 2 个吗？）

tmpSig_0 <= insig_0 + insig_1 + insig_2 + insig_3;
tmpSig_1 <= insig_4 + insig_5 + insig_6 + insig_7;
tmpSig_2 <= insig_8 + insig_9 + insig_10 + insig_11;
tmpSig_3 <= insig_12 + insig_13 + insig_14 + insig_15;

outSig   <= tmpSig_0 + tmpSig_1 + tmpSig_2 + tmpSig_3;

这将是一个 5 行 2 级流水线，而不是更复杂的代码，但您需要再次检查它是否满足时序要求。

于 2013-09-19T15:47:59.783 回答
0

生成循环怎么样。我还没有测试过这个代码片段，但我在这里记下它是为了说明。

parameter num_of_additions = 16
genvar i,j,k;
generate
  begin 
  for (k=0;k<(num_of_additions>>3);k=k+1)
     begin : adder_l3
        tmp_sig_l3[k] = summedOutput(tmp_sig_l2[k], tmp_sig_l2[k+1));
        oflw_l3[k] = {additionOverflow (tmp_sig_l2[k*2],tmp_sig_l2[(k*2)+1],
                                        tmp_sig_l2[(k*2)]+tmp_sig_l2[(k*2)+1])};
     end : adder_l3

   for (j=0;j<(num_of_additions>>2);j=j+1)
     begin : adder_l2
        tmp_sig_l2[j] = summedOutput(tmp_sig_l1[j], tmp_sig_l1[j+1));
        oflw_l2[j] = {additionOverflow (tmp_sig_l1[j*2],tmp_sig_l1[(j*2)+1],
                                        tmp_sig_l1[(j*2)]+tmp_sig_l1[(j*2)+1])};
     end : adder_l2

   for (i=0;i<(num_of_additions >> 1);i=i+1)
      begin : adder_l1
        tmp_sig_l1[i] = summedOutput(inSig[i], inSig[i+1);
        oflw_l1[i] = {additionOverflow (inSig[i*2],inSig[(i*2)+1],
                                        inSig[(i*2)]+inSig[(i*2)+1])}
      end : adder_l1

   end


endgenerate


//this is not parameterized
assign outSig <= summedOutput(tmp_sig_l3[0], tmp_sig_l3[1]);
overflow <= (| {oflw_l3,oflw_l2,oflw_l1, additionOverflow(tmp_sig_l3[0],tmp_sig_l3[1],
                                                          tmp_sig_l3[0]+tmp_sig_l3[1])};
于 2013-09-19T18:15:39.780 回答