矩阵90°旋转

下面谈谈我对这个问题的看法，如#3所说，这种横纵转换必然是打散了计算，后来我想利用memory cache来
提高速度，对于内存数据，硬盘数据是一个慢速设备，而对于当今的cpu来说，内存又是慢速的了。

我先上网查了一下我的cpu参数：E8400，L1 cache 64k，L2 cache 6M。
然后我设计了数据是1023*1024的矩阵，double类型，这样每一行数据就是1024 * sizeof(double)=8k

这样L1 cache能够装下8行的数据，但是不知道这个缓存是否能够全部利用，经试验装入6行效率最高。我猜
测缓存会装入读取数据的前面一小段和后面一大段（这个只是猜测）。

接下来说说我的算法。

将原始数据6行6行划分成条状，最后的余数不够6行特殊处理，每次读取条状第一个数据的时候，可预计这个
条带会整个被放入L1 cache，对于目标数据，这个条带是纵向的。一条一条的旋转，这样原始数据就不用频繁读取了。

另一种方法是对原始数据进行列划分，而对目标数据进行行划分，这样就相当于对写内存数据进行了缓存，经试验，划分为128时效率最好，我估计写内存的时候应该和L2 cache关系较大，这样算下来，8k*128=1M，也就是说6M 的L2 cache可以利用大约1M来优化写内存？或者是操作系统规定大约缓存1M的数据就开始写内存？
我也不知道是否如此。

以上说法都是个人观点，不一定准确。

我的环境：win7 64bit VS2008 debug/x64
下面是我的测试时间，可以看出读缓存可以快大约4倍，另外，先测试的函数往往要多耗时间：

编译器选项/Od
CacheRead:      1985498775
CacheWrite:    2279309904
Simple:        7816269690
Press any key to continue . . .

编译器选项/O2
CacheRead:      1334952851
CacheWrite:    1714044429
Simple:        4617906147
Press any key to continue . . .

C/C++ code

    
    
    
    

     
     
     
     
      #include 
     
     
     
     <
     
     
     
     stdio.h
     
     
     
     >
     
     
     
      #include 
     
     
     
     <
     
     
     
     stdlib.h
     
     
     
     >
     
     
     
      #include 
     
     
     
     <
     
     
     
     memory.h
     
     
     
     >
     
     
     
      #include 
     
     
     
     <
     
     
     
     intrin.h
     
     
     
     >
     
     
     
      
     
     
     
     #pragma
     
     
     
      intrinsic(__rdtsc)
     
     
     
      
     
     
     
     #define
     
     
     
      M 2047
     
     
     
      
     
     
     
     #define
     
     
     
      N 2048
     
     
     
      __declspec( align(
     
     
     
     128
     
     
     
     ) ) 
     
     
     
     double
     
     
     
      aMatrix[M
     
     
     
     *
     
     
     
     N]; __declspec( align(
     
     
     
     128
     
     
     
     ) ) 
     
     
     
     double
     
     
     
      bMatrix[N
     
     
     
     *
     
     
     
     M]; 
     
     
     
     void
     
     
     
      Rot90_Simple( 
     
     
     
     double
     
     
     
      
     
     
     
     *
     
     
     
     pDst, 
     
     
     
     double
     
     
     
      
     
     
     
     *
     
     
     
     pSrc, 
     
     
     
     int
     
     
     
      width, 
     
     
     
     int
     
     
     
      height ) { 
     
     
     
     int
     
     
     
      dataSize 
     
     
     
     =
     
     
     
      width 
     
     
     
     *
     
     
     
      height; 
     
     
     
     double
     
     
     
     *
     
     
     
      pRunner 
     
     
     
     =
     
     
     
      pSrc 
     
     
     
     +
     
     
     
      width 
     
     
     
     -
     
     
     
      
     
     
     
     1
     
     
     
     ; 
     
     
     
     double
     
     
     
     *
     
     
     
      pSrcEnd 
     
     
     
     =
     
     
     
      pSrc 
     
     
     
     +
     
     
     
      dataSize; 
     
     
     
     double
     
     
     
     *
     
     
     
      pDstEnd 
     
     
     
     =
     
     
     
      pDst 
     
     
     
     +
     
     
     
      dataSize; 
     
     
     
     ++
     
     
     
     dataSize; 
     
     
     
     while
     
     
     
     ( pDst 
     
     
     
     <
     
     
     
      pDstEnd ) { 
     
     
     
     *
     
     
     
     pDst
     
     
     
     ++
     
     
     
      
     
     
     
     =
     
     
     
      
     
     
     
     *
     
     
     
     pRunner; pRunner 
     
     
     
     +=
     
     
     
      width; 
     
     
     
     if
     
     
     
     ( pRunner 
     
     
     
     >
     
     
     
      pSrcEnd ) pRunner 
     
     
     
     -=
     
     
     
      dataSize; } } 
     
     
     
     void
     
     
     
      Rot90_CacheWrite( 
     
     
     
     double
     
     
     
      
     
     
     
     *
     
     
     
     pDst, 
     
     
     
     double
     
     
     
      
     
     
     
     *
     
     
     
     pSrc, 
     
     
     
     int
     
     
     
      width, 
     
     
     
     int
     
     
     
      height ) { 
     
     
     
     int
     
     
     
      blockSize 
     
     
     
     =
     
     
     
      
     
     
     
     128
     
     
     
     ; 
     
     
     
     int
     
     
     
      wblock 
     
     
     
     =
     
     
     
      width 
     
     
     
     /
     
     
     
      blockSize; 
     
     
     
     int
     
     
     
      hblock 
     
     
     
     =
     
     
     
      height 
     
     
     
     /
     
     
     
      blockSize; 
     
     
     
     int
     
     
     
      wlast 
     
     
     
     =
     
     
     
      width 
     
     
     
     -
     
     
     
      blockSize 
     
     
     
     *
     
     
     
      wblock; 
     
     
     
     int
     
     
     
      hlast 
     
     
     
     =
     
     
     
      height 
     
     
     
     -
     
     
     
      blockSize 
     
     
     
     *
     
     
     
      hblock; 
     
     
     
     int
     
     
     
      nextRow 
     
     
     
     =
     
     
     
      width 
     
     
     
     +
     
     
     
      blockSize; 
     
     
     
     int
     
     
     
      nextCol 
     
     
     
     =
     
     
     
      blockSize 
     
     
     
     *
     
     
     
      height 
     
     
     
     -
     
     
     
      
     
     
     
     1
     
     
     
     ; 
     
     
     
     int
     
     
     
      dataSize 
     
     
     
     =
     
     
     
      width 
     
     
     
     *
     
     
     
      height; 
     
     
     
     double
     
     
     
      preRead 
     
     
     
     =
     
     
     
      
     
     
     
     *
     
     
     
     pSrc; 
     
     
     
     double
     
     
     
     *
     
     
     
      pRunner 
     
     
     
     =
     
     
     
      pSrc 
     
     
     
     +
     
     
     
      width 
     
     
     
     -
     
     
     
      
     
     
     
     1
     
     
     
     ; 
     
     
     
     double
     
     
     
     *
     
     
     
      pSrcEnd 
     
     
     
     =
     
     
     
      pSrc 
     
     
     
     +
     
     
     
      dataSize; 
     
     
     
     double
     
     
     
     *
     
     
     
      pDstEnd 
     
     
     
     =
     
     
     
      pDst 
     
     
     
     +
     
     
     
      dataSize; 
     
     
     
     for
     
     
     
     ( 
     
     
     
     int
     
     
     
      i 
     
     
     
     =
     
     
     
      
     
     
     
     0
     
     
     
     ; i 
     
     
     
     <
     
     
     
      wblock; 
     
     
     
     ++
     
     
     
     i ) { 
     
     
     
     while
     
     
     
     ( pRunner 
     
     
     
     <
     
     
     
      pSrcEnd ) { 
     
     
     
     for
     
     
     
     ( 
     
     
     
     int
     
     
     
      j 
     
     
     
     =
     
     
     
      
     
     
     
     0
     
     
     
     ; j 
     
     
     
     <
     
     
     
      blockSize; 
     
     
     
     ++
     
     
     
     j ) { 
     
     
     
     *
     
     
     
     pDst 
     
     
     
     =
     
     
     
      
     
     
     
     *
     
     
     
     pRunner
     
     
     
     --
     
     
     
     ; pDst 
     
     
     
     +=
     
     
     
      height; } pDst 
     
     
     
     -=
     
     
     
      nextCol; pRunner 
     
     
     
     +=
     
     
     
      nextRow; } pDst 
     
     
     
     +=
     
     
     
      ( nextCol 
     
     
     
     -
     
     
     
      height 
     
     
     
     +
     
     
     
      
     
     
     
     1
     
     
     
      ); 
     
     
     
     //
     
     
     
     preRead = pRunner[nextCol];
     
     
     
      
     
     
     
      pRunner 
     
     
     
     -=
     
     
     
      ( dataSize 
     
     
     
     +
     
     
     
      blockSize ); } nextCol 
     
     
     
     =
     
     
     
      wlast 
     
     
     
     *
     
     
     
      height 
     
     
     
     -
     
     
     
      
     
     
     
     1
     
     
     
     ; nextRow 
     
     
     
     =
     
     
     
      width 
     
     
     
     +
     
     
     
      wlast; 
     
     
     
     while
     
     
     
     ( pRunner 
     
     
     
     <
     
     
     
      pSrcEnd ) { 
     
     
     
     for
     
     
     
     ( 
     
     
     
     int
     
     
     
      j 
     
     
     
     =
     
     
     
      
     
     
     
     0
     
     
     
     ; j 
     
     
     
     <
     
     
     
      wlast; 
     
     
     
     ++
     
     
     
     j ) { 
     
     
     
     *
     
     
     
     pDst 
     
     
     
     =
     
     
     
      
     
     
     
     *
     
     
     
     pRunner
     
     
     
     --
     
     
     
     ; pDst 
     
     
     
     +=
     
     
     
      height; } pDst 
     
     
     
     -=
     
     
     
      nextCol; pRunner 
     
     
     
     +=
     
     
     
      nextRow; } } 
     
     
     
     void
     
     
     
      Rot90_CacheRead( 
     
     
     
     double
     
     
     
      
     
     
     
     *
     
     
     
     pDst, 
     
     
     
     double
     
     
     
      
     
     
     
     *
     
     
     
     pSrc, 
     
     
     
     int
     
     
     
      width, 
     
     
     
     int
     
     
     
      height ) { 
     
     
     
     int
     
     
     
      blockSize 
     
     
     
     =
     
     
     
      
     
     
     
     6
     
     
     
     ; 
     
     
     
     int
     
     
     
      wblock 
     
     
     
     =
     
     
     
      width 
     
     
     
     /
     
     
     
      blockSize; 
     
     
     
     int
     
     
     
      hblock 
     
     
     
     =
     
     
     
      height 
     
     
     
     /
     
     
     
      blockSize; 
     
     
     
     int
     
     
     
      wlast 
     
     
     
     =
     
     
     
      width 
     
     
     
     -
     
     
     
      blockSize 
     
     
     
     *
     
     
     
      wblock; 
     
     
     
     int
     
     
     
      hlast 
     
     
     
     =
     
     
     
      height 
     
     
     
     -
     
     
     
      blockSize 
     
     
     
     *
     
     
     
      hblock; 
     
     
     
     int
     
     
     
      nextRow 
     
     
     
     =
     
     
     
      height 
     
     
     
     -
     
     
     
      blockSize; 
     
     
     
     int
     
     
     
      nextCol 
     
     
     
     =
     
     
     
      blockSize 
     
     
     
     *
     
     
     
      width 
     
     
     
     +
     
     
     
      
     
     
     
     1
     
     
     
     ; 
     
     
     
     int
     
     
     
      dataSize 
     
     
     
     =
     
     
     
      width 
     
     
     
     *
     
     
     
      height; 
     
     
     
     double
     
     
     
      preRead 
     
     
     
     =
     
     
     
      
     
     
     
     *
     
     
     
     pSrc; 
     
     
     
     double
     
     
     
     *
     
     
     
      pRunner 
     
     
     
     =
     
     
     
      pSrc 
     
     
     
     +
     
     
     
      width 
     
     
     
     -
     
     
     
      
     
     
     
     1
     
     
     
     ; 
     
     
     
     double
     
     
     
     *
     
     
     
      pSrcEnd 
     
     
     
     =
     
     
     
      pSrc 
     
     
     
     +
     
     
     
      dataSize; 
     
     
     
     double
     
     
     
     *
     
     
     
      pDstEnd 
     
     
     
     =
     
     
     
      pDst 
     
     
     
     +
     
     
     
      dataSize; 
     
     
     
     for
     
     
     
     ( 
     
     
     
     int
     
     
     
      i 
     
     
     
     =
     
     
     
      
     
     
     
     0
     
     
     
     ; i 
     
     
     
     <
     
     
     
      hblock; 
     
     
     
     ++
     
     
     
     i ) { 
     
     
     
     while
     
     
     
     ( pDst 
     
     
     
     <
     
     
     
      pDstEnd ) { 
     
     
     
     for
     
     
     
     ( 
     
     
     
     int
     
     
     
      j 
     
     
     
     =
     
     
     
      
     
     
     
     0
     
     
     
     ; j 
     
     
     
     <
     
     
     
      blockSize; 
     
     
     
     ++
     
     
     
     j ) { 
     
     
     
     *
     
     
     
     pDst
     
     
     
     ++
     
     
     
      
     
     
     
     =
     
     
     
      
     
     
     
     *
     
     
     
     pRunner; pRunner 
     
     
     
     +=
     
     
     
      width; } pDst 
     
     
     
     +=
     
     
     
      nextRow; pRunner 
     
     
     
     -=
     
     
     
      nextCol; } pDst 
     
     
     
     -=
     
     
     
      ( dataSize 
     
     
     
     -
     
     
     
      blockSize ); preRead 
     
     
     
     =
     
     
     
      pRunner[nextCol]; pRunner 
     
     
     
     +=
     
     
     
      ( nextCol 
     
     
     
     +
     
     
     
      width 
     
     
     
     -
     
     
     
      
     
     
     
     1
     
     
     
      ); } nextRow 
     
     
     
     =
     
     
     
      height 
     
     
     
     -
     
     
     
      hlast; nextCol 
     
     
     
     =
     
     
     
      hlast 
     
     
     
     *
     
     
     
      width 
     
     
     
     +
     
     
     
      
     
     
     
     1
     
     
     
     ; 
     
     
     
     while
     
     
     
     ( pDst 
     
     
     
     <
     
     
     
      pDstEnd ) { 
     
     
     
     for
     
     
     
     ( 
     
     
     
     int
     
     
     
      j 
     
     
     
     =
     
     
     
      
     
     
     
     0
     
     
     
     ; j 
     
     
     
     <
     
     
     
      hlast; 
     
     
     
     ++
     
     
     
     j ) { 
     
     
     
     *
     
     
     
     pDst
     
     
     
     ++
     
     
     
      
     
     
     
     =
     
     
     
      
     
     
     
     *
     
     
     
     pRunner; pRunner 
     
     
     
     +=
     
     
     
      width; } pDst 
     
     
     
     +=
     
     
     
      nextRow; pRunner 
     
     
     
     -=
     
     
     
      nextCol; } } 
     
     
     
     float
     
     
     
      main() { unsigned __int64 t1, t2, t; 
     
     
     
     int
     
     
     
      times 
     
     
     
     =
     
     
     
      
     
     
     
     20
     
     
     
     ; 
     
     
     
     for
     
     
     
     ( 
     
     
     
     int
     
     
     
      i 
     
     
     
     =
     
     
     
      
     
     
     
     0
     
     
     
     ; i 
     
     
     
     <
     
     
     
      N 
     
     
     
     *
     
     
     
      M; i
     
     
     
     ++
     
     
     
      ) aMatrix[i] 
     
     
     
     =
     
     
     
      
     
     
     
     1.0
     
     
     
      
     
     
     
     *
     
     
     
      rand() 
     
     
     
     /
     
     
     
      RAND_MAX; t1 
     
     
     
     =
     
     
     
      __rdtsc(); 
     
     
     
     for
     
     
     
     ( 
     
     
     
     int
     
     
     
      i 
     
     
     
     =
     
     
     
      
     
     
     
     0
     
     
     
     ; i 
     
     
     
     <
     
     
     
      times ; 
     
     
     
     ++
     
     
     
     i ) Rot90_CacheRead( bMatrix, aMatrix, N, M ); 
     
     
     
     //
     
     
     
     memcpy( aMatrix, bMatrix, M*N*sizeof(double) );
     
     
     
      
     
     
     
      t2 
     
     
     
     =
     
     
     
      __rdtsc(); t 
     
     
     
     =
     
     
     
      t2 
     
     
     
     -
     
     
     
      t1; printf( 
     
     
     
     "
     
     
     
     CacheRead:/t%llu/n
     
     
     
     "
     
     
     
     , t ); 
     
     
     
     for
     
     
     
     ( 
     
     
     
     int
     
     
     
      i 
     
     
     
     =
     
     
     
      
     
     
     
     0
     
     
     
     ; i 
     
     
     
     <
     
     
     
      N 
     
     
     
     *
     
     
     
      M; i
     
     
     
     ++
     
     
     
      ) aMatrix[i] 
     
     
     
     =
     
     
     
      
     
     
     
     1.0
     
     
     
      
     
     
     
     *
     
     
     
      rand() 
     
     
     
     /
     
     
     
      RAND_MAX; t1 
     
     
     
     =
     
     
     
      __rdtsc(); 
     
     
     
     for
     
     
     
     ( 
     
     
     
     int
     
     
     
      i 
     
     
     
     =
     
     
     
      
     
     
     
     0
     
     
     
     ; i 
     
     
     
     <
     
     
     
      times ; 
     
     
     
     ++
     
     
     
     i ) Rot90_CacheWrite( bMatrix, aMatrix, N, M ); 
     
     
     
     //
     
     
     
     memcpy( aMatrix, bMatrix, M*N*sizeof(double) );
     
     
     
      
     
     
     
      t2 
     
     
     
     =
     
     
     
      __rdtsc(); t 
     
     
     
     =
     
     
     
      t2 
     
     
     
     -
     
     
     
      t1; printf( 
     
     
     
     "
     
     
     
     CacheWrite:/t%llu/n
     
     
     
     "
     
     
     
     , t ); 
     
     
     
     for
     
     
     
     ( 
     
     
     
     int
     
     
     
      i 
     
     
     
     =
     
     
     
      
     
     
     
     0
     
     
     
     ; i 
     
     
     
     <
     
     
     
      N 
     
     
     
     *
     
     
     
      M; i
     
     
     
     ++
     
     
     
      ) aMatrix[i] 
     
     
     
     =
     
     
     
      
     
     
     
     1.0
     
     
     
      
     
     
     
     *
     
     
     
      rand() 
     
     
     
     /
     
     
     
      RAND_MAX; t1 
     
     
     
     =
     
     
     
      __rdtsc(); 
     
     
     
     for
     
     
     
     ( 
     
     
     
     int
     
     
     
      i 
     
     
     
     =
     
     
     
      
     
     
     
     0
     
     
     
     ; i 
     
     
     
     <
     
     
     
      times ; 
     
     
     
     ++
     
     
     
     i ) Rot90_Simple( bMatrix, aMatrix, N, M ); 
     
     
     
     //
     
     
     
     memcpy( aMatrix, bMatrix, M*N*sizeof(double) );
     
     
     
      
     
     
     
      t2 
     
     
     
     =
     
     
     
      __rdtsc(); t 
     
     
     
     =
     
     
     
      t2 
     
     
     
     -
     
     
     
      t1; printf( 
     
     
     
     "
     
     
     
     Simple:/t/t%llu/n
     
     
     
     "
     
     
     
     , t ); 
     
     
     
     return
     
     
     
      
     
     
     
     0
     
     
     
     .f; }