矢量化其访问非连续的存储器位置

Question

一个循环我有这样的结构的环

参考：Maxwell Code Example

do z=1,zend 
    do y=1,yend 
     do x=1,xend 
      k=arr(x,y,z) 
      do while(k.ne.0) 
       ix=fooX(k) 
       iy=fooY(k) 
       iz=fooZ(k) 
       x1=x(ix ,iy ,iz) 
       x2=x(ix+1,iy ,iz) 
       x3=x(ix ,iy+1,iz) 
       x4=x(ix+1,iy+1,iz) 
       x5=x(ix ,iy ,iz+1) 
       x6=x(ix+1,iy ,iz+1) 
       x7=x(ix ,iy+1,iz+1) 
       x8=x(ix+1,iy+1,iz+1) 

       y1=y(ix ,iy ,iz) 
       y2=y(ix+1,iy ,iz) 
       y3=y(ix ,iy+1,iz) 
       y4=y(ix+1,iy+1,iz) 
       y5=y(ix ,iy ,iz+1) 
       y6=y(ix+1,iy ,iz+1) 
       y7=y(ix ,iy+1,iz+1) 
       y8=y(ix+1,iy+1,iz+1) 

       z1=z(ix ,iy ,iz) 
       z2=z(ix+1,iy ,iz) 
       z3=z(ix ,iy+1,iz) 
       z4=z(ix+1,iy+1,iz) 
       z5=z(ix ,iy ,iz+1) 
       z6=z(ix+1,iy ,iz+1) 
       z7=z(ix ,iy+1,iz+1) 
       z8=z(ix+1,iy+1,iz+1) 
       sumX+=x1+x2+..x8 
       sumY+=y1+y2+..y8 
       sumZ+=z1+z2+..z8 

       k=linkArr(k) 
      enddo 
     enddo 
    enddo 
enddo 

X1到X8是长方体的8个角。向量化代码有三个挑战。一个是8个数组元素在内存中不连续。其次是固有的while循环结构以及链接的List访问。第三，从fooX，fooY，fooZ返回的ix，iy，iz的值不是连续的。所以循环的每次迭代都有一组完全不同的ix，iy，iz。所以即使在迭代中，内存访问也是分散的。 我尝试以下方法：1。 展开的3级DO循环为：

do z=1,zend 
    do y=1,yend 
     do x=1,xend 
      if(arr(x,y,z).NE.0) then 
       kArr(indx)=arr(x,y,z) 
       DO WHILE (kArr(indx).NE.0) 
        indx = indx + 1 
        kArr(indx)=linkArr(kArr(indx-1)) 
       ENDDO 
      endif 
     enddo 
    enddo 
enddo 

有了这个，我已经摆脱了while循环结构的，现在我能够在卡尔运行一个大循环其中我组8个元素（说我的VPU一次可以容纳8组数据）。它没有提高性能。如果有人感兴趣，我可以发布这些细节。我需要关于如何优化此代码的建议。我试过的另一个选择是将x，y，z数据组合到一个单独的数组中，这样当我计算x1时，z1也会在相邻的存储单元中。

Answer 1

while while循环正在杀死你。在类似的情况在几年前，我在性能上略有改善做这样的事情：

! at top of your code, introduce: 
integer :: special_index 
integer :: ix(1000), iy(1000), iz(1000) !promoting scalars to arrays. 
             ! make as big as possibly needed. 

! code as usual until you get to your loops, then 

! first, make lookup table 
special_index=0 
do z=1,zend 
    do y=1,yend 
    do x=1,xend 
     k=arr(x,y,z) 
     do while(k.ne.0) 
     special_index=special_index+1 
     ix(special_index)=fooX(k) 
     iy(special_index)=fooY(k) 
     iz(special_index)=fooZ(k) 
     k=linkArr(k) 
     enddo 
    enddo 
    enddo 
endoo 
! and now we do the calculation, loop over lookup table: 
do n=1,special_index 
    x1=x(ix(n) ,iy(n) ,iz(n)) 
    x2=x(ix(n)+1,iy(n) ,iz(n)) 
    x3=x(ix(n) ,iy(n)+1,iz(n)) 
    etc. 
enddo 

就像我说的，这帮助我在几年前。你的旅费可能会改变。第一个循环仍然不会矢量化，但第二个循环可能会提供更好的性能。