Đây là một câu hỏi hay. Có nhiều lý do mà bạn muốn thực sự chuyển ma trận trong bộ nhớ thay vì chỉ hoán đổi tọa độ, ví dụ như trong phép nhân ma trận và bôi bẩn Gauss.
Trước tiên, hãy để tôi liệt kê một trong những hàm tôi sử dụng cho phép chuyển vị ( CHỈNH SỬA: vui lòng xem phần cuối câu trả lời của tôi, nơi tôi tìm thấy một giải pháp nhanh hơn nhiều )
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];
}
}
Bây giờ chúng ta hãy xem tại sao chuyển vị lại hữu ích. Xét phép nhân ma trận C = A * B. Chúng tôi có thể làm theo cách này.
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ằng cách đó, tuy nhiên, sẽ có rất nhiều bộ nhớ cache bị bỏ sót. Một giải pháp nhanh hơn nhiều là chuyển vị trí của B trước
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);
Phép nhân ma trận là O (n ^ 3) và phép chuyển vị là O (n ^ 2), vì vậy việc lấy phép chuyển vị sẽ ảnh hưởng không đáng kể đến thời gian tính toán (đối với lớn n). Trong phép nhân ma trận, việc xếp gạch vòng lặp thậm chí còn hiệu quả hơn việc lấy phép chuyển vị nhưng điều đó phức tạp hơn nhiều.
Tôi ước tôi biết một cách nhanh hơn để thực hiện chuyển vị ( Chỉnh sửa: Tôi đã tìm thấy một giải pháp nhanh hơn, xem phần cuối của câu trả lời của tôi ). Khi Haswell / AVX2 ra mắt trong vài tuần tới, nó sẽ có chức năng tập hợp. Tôi không biết liệu điều đó có hữu ích trong trường hợp này hay không nhưng tôi có thể hình ảnh tập hợp một cột và viết ra một hàng. Có thể nó sẽ làm cho việc chuyển đổi không cần thiết.
Đối với cách bôi Gaussian, những gì bạn làm là bôi theo chiều ngang và sau đó bôi theo chiều dọc. Nhưng bôi bẩn theo chiều dọc có vấn đề về bộ nhớ cache, vì vậy những gì bạn làm là
Smear image horizontally
transpose output
Smear output horizontally
transpose output
Đây là một bài báo của Intel giải thích rằng
http://software.intel.com/en-us/articles/iir-gaussian-blur-filter-implementation-using-intel-advanced-vector-extensions
Cuối cùng, những gì tôi thực sự làm trong phép nhân ma trận (và trong phép bôi Gaussian) không phải là lấy chính xác chuyển vị mà lấy chuyển vị theo độ rộng của một kích thước vectơ nhất định (ví dụ: 4 hoặc 8 cho SSE / AVX). Đây là chức năng tôi sử dụng
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];
}
}
BIÊN TẬP:
Tôi đã thử một số chức năng để tìm chuyển vị nhanh nhất cho ma trận lớn. Cuối cùng, kết quả nhanh nhất là sử dụng chặn vòng lặp với block_size=16( Chỉnh sửa: Tôi đã tìm thấy một giải pháp nhanh hơn bằng cách sử dụng SSE và chặn vòng lặp - xem bên dưới ). Mã này hoạt động với bất kỳ ma trận NxM nào (tức là ma trận không phải là hình vuông).
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);
}
}
}
Các giá trị ldavà ldblà chiều rộng của ma trận. Chúng phải là bội số của kích thước khối. Để tìm các giá trị và cấp phát bộ nhớ cho ma trận 3000x1001, tôi làm như sau
#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);
Đối với 3000x1001, nó trả về ldb = 3008và lda = 1008
Biên tập:
Tôi đã tìm thấy một giải pháp thậm chí còn nhanh hơn bằng cách sử dụng bản chất 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);
}
}
}
}
}