これは良い質問です。行列の乗算やガウススミアリングなど、座標を交換するだけでなく、実際に行列をメモリ内で転置したい理由はたくさんあります。
まず、転置に使用する関数の1つをリストします（編集：はるかに高速な解決策を見つけた私の回答の最後を参照してください）
void transpose(float *src, float *dst, const int N, const int M) {
#pragma omp parallel for
for(int n = 0; n<N*M; n++) {
int i = n/N;
int j = n%N;
dst[n] = src[M*j + i];
}
}
それでは、転置が役立つ理由を見てみましょう。行列の乗算C = A * Bを考えてみましょう。この方法でそれを行うことができます。
for(int i=0; i<N; i++) {
for(int j=0; j<K; j++) {
float tmp = 0;
for(int l=0; l<M; l++) {
tmp += A[M*i+l]*B[K*l+j];
}
C[K*i + j] = tmp;
}
}
ただし、そうすると、多くのキャッシュミスが発生します。はるかに高速な解決策は、最初にBの転置を行うことです。
transpose(B);
for(int i=0; i<N; i++) {
for(int j=0; j<K; j++) {
float tmp = 0;
for(int l=0; l<M; l++) {
tmp += A[M*i+l]*B[K*j+l];
}
C[K*i + j] = tmp;
}
}
transpose(B);
行列の乗算はO（n ^ 3）であり、転置はO（n ^ 2）であるため、転置を行うことによる計算時間への影響はごくわずかです（大きい場合n）。行列乗算では、ループタイリングは転置を行うよりもさらに効果的ですが、それははるかに複雑です。
転置を行うためのより速い方法を知っていればいいのですが（編集：より速い解決策を見つけました。答えの終わりを参照してください）。Haswell / AVX2が数週間で発売されると、収集機能が追加されます。この場合、それが役立つかどうかはわかりませんが、列を集めて行を書き出すイメージはできます。多分それは転置を不必要にするでしょう。
ガウススミアリングの場合、水平方向にスミアし、次に垂直方向にスミアします。しかし、垂直方向に塗り付けるとキャッシュの問題が発生するため、
Smear image horizontally
transpose output
Smear output horizontally
transpose output
これは、http：//software.intel.com/en-us/articles/iir-gaussian-blur-filter-implementation-using-intel-advanced-vector-extensionsについて説明しているIntelの論文です。
最後に、行列乗算（およびガウススミアリング）で実際に行うことは、転置を正確に行うのではなく、特定のベクトルサイズ（SSE / AVXの場合は4または8など）の幅で転置を行うことです。これが私が使っている関数です
void reorder_matrix(const float* A, float* B, const int N, const int M, const int vec_size) {
#pragma omp parallel for
for(int n=0; n<M*N; n++) {
int k = vec_size*(n/N/vec_size);
int i = (n/vec_size)%N;
int j = n%vec_size;
B[n] = A[M*i + k + j];
}
}
編集：
大きな行列の最速の移調を見つけるために、いくつかの関数を試しました。結局のところ、最速の結果はでループブロッキングを使用することですblock_size=16（編集：SSEとループブロッキングを使用したより高速なソリューションを見つけました-以下を参照）。このコードは、任意のNxM行列で機能します（つまり、行列は正方形である必要はありません）。
inline void transpose_scalar_block(float *A, float *B, const int lda, const int ldb, const int block_size) {
#pragma omp parallel for
for(int i=0; i<block_size; i++) {
for(int j=0; j<block_size; j++) {
B[j*ldb + i] = A[i*lda +j];
}
}
}
inline void transpose_block(float *A, float *B, const int n, const int m, const int lda, const int ldb, const int block_size) {
#pragma omp parallel for
for(int i=0; i<n; i+=block_size) {
for(int j=0; j<m; j+=block_size) {
transpose_scalar_block(&A[i*lda +j], &B[j*ldb + i], lda, ldb, block_size);
}
}
}
値ldaとldbは行列の幅です。これらはブロックサイズの倍数である必要があります。値を見つけて、たとえば3000x1001マトリックスにメモリを割り当てるには、次のようにします。
#define ROUND_UP(x, s) (((x)+((s)-1)) & -(s))
const int n = 3000;
const int m = 1001;
int lda = ROUND_UP(m, 16);
int ldb = ROUND_UP(n, 16);
float *A = (float*)_mm_malloc(sizeof(float)*lda*ldb, 64);
float *B = (float*)_mm_malloc(sizeof(float)*lda*ldb, 64);
3000x1001の場合、このリターン ldb = 3008と lda = 1008
編集：
SSE組み込み関数を使用したさらに高速なソリューションを見つけました。
inline void transpose4x4_SSE(float *A, float *B, const int lda, const int ldb) {
__m128 row1 = _mm_load_ps(&A[0*lda]);
__m128 row2 = _mm_load_ps(&A[1*lda]);
__m128 row3 = _mm_load_ps(&A[2*lda]);
__m128 row4 = _mm_load_ps(&A[3*lda]);
_MM_TRANSPOSE4_PS(row1, row2, row3, row4);
_mm_store_ps(&B[0*ldb], row1);
_mm_store_ps(&B[1*ldb], row2);
_mm_store_ps(&B[2*ldb], row3);
_mm_store_ps(&B[3*ldb], row4);
}
inline void transpose_block_SSE4x4(float *A, float *B, const int n, const int m, const int lda, const int ldb ,const int block_size) {
#pragma omp parallel for
for(int i=0; i<n; i+=block_size) {
for(int j=0; j<m; j+=block_size) {
int max_i2 = i+block_size < n ? i + block_size : n;
int max_j2 = j+block_size < m ? j + block_size : m;
for(int i2=i; i2<max_i2; i2+=4) {
for(int j2=j; j2<max_j2; j2+=4) {
transpose4x4_SSE(&A[i2*lda +j2], &B[j2*ldb + i2], lda, ldb);
}
}
}
}
}