Який найшвидший спосіб транспортувати матрицю в C ++?

У мене є матриця (відносно велика), яку мені потрібно транспонувати. Наприклад, припустимо, що моя матриця є

a b c d e f
g h i j k l
m n o p q r 

Я хочу, щоб результат був таким:

a g m
b h n
c I o
d j p
e k q
f l r

Який найшвидший спосіб це зробити?

Це гарне запитання. Є багато причин, чому ви хотіли б фактично транспонувати матрицю в пам’ять, а не просто обмінюватись координатами, наприклад, при множенні матриці та розмиванні Гауса.

Спочатку дозвольте мені перерахувати одну з функцій, яку я використовую для транспонування ( EDIT: будь ласка, див. Кінець моєї відповіді, де я знайшов набагато швидше рішення )

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

Ось стаття від Intel, яка пояснює, що http://software.intel.com/en-us/articles/iir-gaussian-blur-filter-implementation-using-intel-advanced-vector-extensions

Нарешті, те, що я насправді роблю при множенні матриць (і при розмиванні Гауса), - це не точне транспонування, а транспонування у ширину певного розміру вектора (наприклад, 4 або 8 для SSE / AVX). Ось функція, яку я використовую

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);
                }
            }
        }
    }
}

Це залежатиме від вашої програми, але загалом найшвидшим способом транспонування матриці буде інвертування ваших координат, коли ви шукаєте, тоді вам не потрібно фактично переміщувати будь-які дані.

Деякі подробиці щодо транспонування матриць квадратного плаваючого формату 4х4 (я обговорю 32-бітове ціле число пізніше) з апаратним забезпеченням x86. Корисно почати тут, щоб транспонувати великі квадратні матриці, такі як 8x8 або 16x16.

_MM_TRANSPOSE4_PS(r0, r1, r2, r3)реалізується різними компіляторами. GCC та ICC (я не перевіряв Clang) використовують, unpcklps, unpckhps, unpcklpd, unpckhpdтоді як MSVC використовує лише shufps. Насправді ми можемо поєднати ці два підходи разом.

t0 = _mm_unpacklo_ps(r0, r1);
t1 = _mm_unpackhi_ps(r0, r1);
t2 = _mm_unpacklo_ps(r2, r3);
t3 = _mm_unpackhi_ps(r2, r3);

r0 = _mm_shuffle_ps(t0,t2, 0x44);
r1 = _mm_shuffle_ps(t0,t2, 0xEE);
r2 = _mm_shuffle_ps(t1,t3, 0x44);
r3 = _mm_shuffle_ps(t1,t3, 0xEE);

Одне цікаве спостереження полягає в тому, що два перетасовки можна перетворити на одне перетасовку і дві суміші (SSE4.1), як це.

t0 = _mm_unpacklo_ps(r0, r1);
t1 = _mm_unpackhi_ps(r0, r1);
t2 = _mm_unpacklo_ps(r2, r3);
t3 = _mm_unpackhi_ps(r2, r3);

v  = _mm_shuffle_ps(t0,t2, 0x4E);
r0 = _mm_blend_ps(t0,v, 0xC);
r1 = _mm_blend_ps(t2,v, 0x3);
v  = _mm_shuffle_ps(t1,t3, 0x4E);
r2 = _mm_blend_ps(t1,v, 0xC);
r3 = _mm_blend_ps(t3,v, 0x3);

Це ефективно перетворило 4 перетасовки в 2 перетасовки і 4 суміші. Тут використано на 2 інструкції більше, ніж впровадження GCC, ICC та MSVC. Перевага полягає в тому, що він зменшує тиск у порту, що може мати вигоду за певних обставин. В даний час всі перетасовки та розпакування можуть надходити лише до одного конкретного порту, тоді як суміші можуть надходити до будь-якого з двох різних портів.

Я спробував використовувати 8 перетасовк, як MSVC, і перетворити їх на 4 перетасовки + 8 сумішей, але це не спрацювало. Мені все-таки довелося використовувати 4 розпакування.

Я використовував цю саму техніку для транспонування 8x8 з плаваючою точкою (див. Наприкінці цієї відповіді). https://stackoverflow.com/a/25627536/2542702 . У цій відповіді мені все-таки довелося використати 8 розпаковувань, але я зумів перетворити 8 перетасовк у 4 перетасовки та 8 сумішей.

Для 32-розрядних цілих чисел немає нічого подібного shufps(за винятком 128-розрядних перетасовк з AVX512), тому його можна реалізувати лише з розпакованими пакунками, які, на мою думку, не можуть бути перетворені в суміші (ефективно). З AVX512 vshufi32x4діє ефективно, як shufpsза винятком 128-бітових смуг з 4 цілими числами, а не 32-бітовими плаваючими, тому vshufi32x4в деяких випадках цей метод може бути використаний . З Knights Landing перетасовки в чотири рази повільніші (пропускна здатність), ніж суміші.

Розглянемо кожен рядок як стовпець, а кожен стовпець як рядок .. використовуйте j, i замість i, j

демонстрація: http://ideone.com/lvsxKZ

#include <iostream> 
using namespace std;

int main ()
{
    char A [3][3] =
    {
        { 'a', 'b', 'c' },
        { 'd', 'e', 'f' },
        { 'g', 'h', 'i' }
    };

    cout << "A = " << endl << endl;

    // print matrix A
    for (int i=0; i<3; i++)
    {
        for (int j=0; j<3; j++) cout << A[i][j];
        cout << endl;
    }

    cout << endl << "A transpose = " << endl << endl;

    // print A transpose
    for (int i=0; i<3; i++)
    {
        for (int j=0; j<3; j++) cout << A[j][i];
        cout << endl;
    }

    return 0;
}

транспонування без накладних витрат (клас не завершений):

class Matrix{
   double *data; //suppose this will point to data
   double _get1(int i, int j){return data[i*M+j];} //used to access normally
   double _get2(int i, int j){return data[j*N+i];} //used when transposed

   public:
   int M, N; //dimensions
   double (*get_p)(int, int); //functor to access elements  
   Matrix(int _M,int _N):M(_M), N(_N){
     //allocate data
     get_p=&Matrix::_get1; // initialised with normal access 
     }

   double get(int i, int j){
     //there should be a way to directly use get_p to call. but i think even this
     //doesnt incur overhead because it is inline and the compiler should be intelligent
     //enough to remove the extra call
     return (this->*get_p)(i,j);
    }
   void transpose(){ //twice transpose gives the original
     if(get_p==&Matrix::get1) get_p=&Matrix::_get2;
     else get_p==&Matrix::_get1; 
     swap(M,N);
     }
}

можна використовувати так:

Matrix M(100,200);
double x=M.get(17,45);
M.transpose();
x=M.get(17,45); // = original M(45,17)

звичайно, я не турбувався тут з управлінням пам'яттю, що є вирішальною, але іншою темою.

Якщо розмір масивів був відомий раніше, ми могли б використати об'єднання для нашої допомоги. Подобається це-

#include <bits/stdc++.h>
using namespace std;

union ua{
    int arr[2][3];
    int brr[3][2];
};

int main() {
    union ua uav;
    int karr[2][3] = {{1,2,3},{4,5,6}};
    memcpy(uav.arr,karr,sizeof(karr));
    for (int i=0;i<3;i++)
    {
        for (int j=0;j<2;j++)
            cout<<uav.brr[i][j]<<" ";
        cout<<'\n';
    }

    return 0;
}

template <class T>
void transpose( const std::vector< std::vector<T> > & a,
std::vector< std::vector<T> > & b,
int width, int height)
{
    for (int i = 0; i < width; i++)
    {
        for (int j = 0; j < height; j++)
        {
            b[j][i] = a[i][j];
        }
    }
} 

Сучасні бібліотеки лінійної алгебри включають оптимізовані версії найпоширеніших операцій. Багато з них включають динамічну розсилку процесора, яка вибирає найкращу реалізацію для апаратного забезпечення під час виконання програми (без шкоди для портативності).

Це, як правило, краща альтернатива виконанню ручної оптимізації ваших функцій за допомогою власних функцій векторних розширень. Останній прив’яже вашу реалізацію до конкретного постачальника обладнання та моделі: якщо ви вирішите перейти на інший постачальник (наприклад, Power, ARM) або на новіші розширення вектора (наприклад, AVX512), вам доведеться повторно реалізувати його, щоб отримати максимум з них.

Транспонування MKL, наприклад, включає функцію розширення BLAS imatcopy. Ви також можете знайти його в інших реалізаціях, таких як OpenBLAS:

#include <mkl.h>

void transpose( float* a, int n, int m ) {
    const char row_major = 'R';
    const char transpose = 'T';
    const float alpha = 1.0f;
    mkl_simatcopy (row_major, transpose, n, m, alpha, a, n, n);
}

Для проекту C ++ ви можете використовувати Armadillo C ++:

#include <armadillo>

void transpose( arma::mat &matrix ) {
    arma::inplace_trans(matrix);
}

intel mkl пропонує матриці транспонування / копіювання на місці та на місці. ось посилання на документацію . Я б порекомендував спробувати внедрення з місця, оскільки швидше десять на місці та в документації останньої версії mkl містить деякі помилки.

Я думаю, що найшвидший спосіб не повинен займати більше O (n ^ 2), також таким чином ви можете використовувати просто O (1) пробіл:
спосіб зробити це - поміняти місцями в парах, тому що коли ви транспонуєте матрицю, то те, що ви do is: M [i] [j] = M [j] [i], тому зберігайте M [i] [j] у температурі, тоді M [i] [j] = M [j] [i], і останній крок: M [j] [i] = темп. це може бути зроблено за один прохід, тому він повинен мати O (n ^ 2)

моя відповідь транспонована з матриці 3x3

 #include<iostream.h>

#include<math.h>


main()
{
int a[3][3];
int b[3];
cout<<"You must give us an array 3x3 and then we will give you Transposed it "<<endl;
for(int i=0;i<3;i++)
{
    for(int j=0;j<3;j++)
{
cout<<"Enter a["<<i<<"]["<<j<<"]: ";

cin>>a[i][j];

}

}
cout<<"Matrix you entered is :"<<endl;

 for (int e = 0 ; e < 3 ; e++ )

{
    for ( int f = 0 ; f < 3 ; f++ )

        cout << a[e][f] << "\t";


    cout << endl;

    }

 cout<<"\nTransposed of matrix you entered is :"<<endl;
 for (int c = 0 ; c < 3 ; c++ )
{
    for ( int d = 0 ; d < 3 ; d++ )
        cout << a[d][c] << "\t";

    cout << endl;
    }

return 0;
}