如何组织这种运算的结构？

如何组织这种运算的结构？

各位高人，

在我的运算中，需要运算的输入数据是两个233位的很长的数a，b,这是由它的顶层模块传过来的：
input[232:0] a, b;

第一步：我根据变量a和b，需要生成
reg[31:0] Aa[232:0]
reg[31:0] Bb[232:0]
这两个两个数组，寄存器组如下：

Aa[0 ] <= a[31:0];  
Aa[1 ] <= a[32:1];  
Aa[2 ] <= a[33:2];  
Aa[3 ] <= a[34:3];  
Aa[4 ] <= a[35:4];  
........
........
Aa[199] <= a[230:199 ];
Aa[200] <= a[231:200 ];
Aa[201] <= a[232:201 ];
Aa[202] <= {a[0], a[232:202 ] };
Aa[203] <= {a[1:0], a[232:203 ] };
Aa[204] <= {a[2:0], a[232:204 ] };
Aa[205] <= {a[3:0], a[232:205 ] };
........
Aa[229] <= {a[27:0], a[232:229 ] };
Aa[230] <= {a[28:0], a[232:230 ] };
Aa[231] <= {a[29:0], a[232:231 ] };
Aa[232] <= {a[30:0], a[232] };

寄存器组Bb也是同样的这种结构，我就不再重复写了，和Aa一样的多。

规律大家都看出了吧，就是这种循环规律！我是以上面的代码进行的赋值的。



还没完，以后有7、8次计算，
第二步： 每次计算都要预先生成这样三组的寄存器组，每一次后面的下标都不一样，我用xxx表示不同的下标.

A_ax[0]<=Aa[ xxx ];  
A_ax[1]<=Aa[ xxx ];
A_ax[2]<=Aa[ xxx ];
A_ax[3]<=Aa[ xxx ];
...
A_ax[229]<=Aa[ xxx ];
A_ax[230]<=Aa[ xxx ];
A_ax[231]<=Aa[ xxx ];
A_ax[232]<=Aa[ xxx ];

//////////////////////////

B_b0[0 ] <= Bb[ xxx ];    
B_b0[1 ] <= Bb[ xxx ];
B_b0[2 ] <= Bb[ xxx ];
B_b0[3 ] <= Bb[ xxx ];
...
B_b0[229]<=Bb[ xxx ];
B_b0[230]<=Bb[ xxx ];
B_b0[231]<=Bb[ xxx ];
B_b0[232]<=Bb[ xxx ];
----------------
B_b1[0]<=  Bb[0];;    
B_b1[1]<=  Bb[1];  
B_b1[2]<=  Bb[2];
B_b1[3]<=  Bb[3];
B_b1[4]<=  Bb[4];
...
B_b1[229]<=Bb[ xxx ];
B_b1[230]<=Bb[ xxx ];
B_b1[231]<=Bb[ xxx ];
B_b1[232]<=Bb[ xxx ];


第三步：最后才是计算结果：

  t<=
  (A_ax[0]  & (B_b0[0] ^ B_b1[0]) ) ^
  (A_ax[1]  & (B_b0[1] ^ B_b1[1]) ) ^
  (A_ax[2]  & (B_b0[2] ^ B_b1[2]) ) ^
  (A_ax[3]  & (B_b0[3] ^ B_b1[3]) ) ^
  ...
  ...
  (A_ax[230]  & (B_b0[230]  ^ B_b1[230]) ) ^
  (A_ax[231]  & (B_b0[231]  ^ B_b1[231]) ) ^
  (A_ax[232]  & (B_b0[232]  ^ B_b1[232]) ) ;
（这一步我是分散到多个始终周期中完成的）

我的意思不知道我说清楚了没有，计算过程就是这样！


我的本意是想提高计算的并行程度，所有的变量都以寄存组的形式存放，寄存器量非常大，
不知道这样合适不合适？不知道象我的这些数据该如何组织才算合理？请大侠明示！

不过我感觉到占用的资源特别大，综合的时候也特别慢。各位大侠们象这样的问题都是如何处理的，有更好的方案请略指一二，愿闻其详！

在下初入此道，毫无经验，对慷慨指教我将不胜感激！